/*************************************************************************** * nmap_rpc.cc -- Functions related to the RPCGrind facility of Nmap. * * This includes reading the nmap-rpc services file and sending rpc * * queries and interpreting responses. The actual scan engine used for * * rpc grinding is pos_scan (which is not in this file) * * * ***********************IMPORTANT NMAP LICENSE TERMS************************ * * * The Nmap Security Scanner is (C) 1996-2012 Insecure.Com LLC. Nmap is * * also a registered trademark of Insecure.Com LLC. This program is free * * software; you may redistribute and/or modify it under the terms of the * * GNU General Public License as published by the Free Software * * Foundation; Version 2 with the clarifications and exceptions described * * below. This guarantees your right to use, modify, and redistribute * * this software under certain conditions. If you wish to embed Nmap * * technology into proprietary software, we sell alternative licenses * * (contact sales@insecure.com). Dozens of software vendors already * * license Nmap technology such as host discovery, port scanning, OS * * detection, version detection, and the Nmap Scripting Engine. * * * * Note that the GPL places important restrictions on "derived works", yet * * it does not provide a detailed definition of that term. To avoid * * misunderstandings, we interpret that term as broadly as copyright law * * allows. For example, we consider an application to constitute a * * "derivative work" for the purpose of this license if it does any of the * * following: * * o Integrates source code from Nmap * * o Reads or includes Nmap copyrighted data files, such as * * nmap-os-db or nmap-service-probes. * * o Executes Nmap and parses the results (as opposed to typical shell or * * execution-menu apps, which simply display raw Nmap output and so are * * not derivative works.) * * o Integrates/includes/aggregates Nmap into a proprietary executable * * installer, such as those produced by InstallShield. * * o Links to a library or executes a program that does any of the above * * * * The term "Nmap" should be taken to also include any portions or derived * * works of Nmap, as well as other software we distribute under this * * license such as Zenmap, Ncat, and Nping. This list is not exclusive, * * but is meant to clarify our interpretation of derived works with some * * common examples. Our interpretation applies only to Nmap--we don't * * speak for other people's GPL works. * * * * If you have any questions about the GPL licensing restrictions on using * * Nmap in non-GPL works, we would be happy to help. As mentioned above, * * we also offer alternative license to integrate Nmap into proprietary * * applications and appliances. These contracts have been sold to dozens * * of software vendors, and generally include a perpetual license as well * * as providing for priority support and updates. They also fund the * * continued development of Nmap. Please email sales@insecure.com for * * further information. * * * * As a special exception to the GPL terms, Insecure.Com LLC grants * * permission to link the code of this program with any version of the * * OpenSSL library which is distributed under a license identical to that * * listed in the included docs/licenses/OpenSSL.txt file, and distribute * * linked combinations including the two. You must obey the GNU GPL in all * * respects for all of the code used other than OpenSSL. If you modify * * this file, you may extend this exception to your version of the file, * * but you are not obligated to do so. * * * * If you received these files with a written license agreement or * * contract stating terms other than the terms above, then that * * alternative license agreement takes precedence over these comments. * * * * Source is provided to this software because we believe users have a * * right to know exactly what a program is going to do before they run it. * * This also allows you to audit the software for security holes (none * * have been found so far). * * * * Source code also allows you to port Nmap to new platforms, fix bugs, * * and add new features. You are highly encouraged to send your changes * * to nmap-dev@insecure.org for possible incorporation into the main * * distribution. By sending these changes to Fyodor or one of the * * Insecure.Org development mailing lists, or checking them into the Nmap * * source code repository, it is understood (unless you specify otherwise) * * that you are offering the Nmap Project (Insecure.Com LLC) the * * unlimited, non-exclusive right to reuse, modify, and relicense the * * code. Nmap will always be available Open Source, but this is important * * because the inability to relicense code has caused devastating problems * * for other Free Software projects (such as KDE and NASM). We also * * occasionally relicense the code to third parties as discussed above. * * If you wish to specify special license conditions of your * * contributions, just say so when you send them. * * * * This program is distributed in the hope that it will be useful, but * * WITHOUT ANY WARRANTY; without even the implied warranty of * * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU * * General Public License v2.0 for more details at * * http://www.gnu.org/licenses/gpl-2.0.html , or in the COPYING file * * included with Nmap. * * * ***************************************************************************/ /* $Id$ */ #include "nmap_rpc.h" #include "NmapOps.h" #include "Target.h" #include "charpool.h" #include "timing.h" #include "nmap_error.h" #include "utils.h" #include "nbase.h" extern NmapOps o; static struct rpc_info ri; static int udp_rpc_socket = -1; static int tcp_rpc_socket = -1; static unsigned long rpc_xid_base = (unsigned long) -1; /* The XID we send in queries is this random base number + the RPC prog number we are scanning for */ static size_t tcp_readlen=0; /* used in get_rpc_results but can be reset in send_rpc_query */ static void rpc_services_init() { static int services_initialized = 0; if (services_initialized) return; services_initialized = 1; char filename[512]; FILE *fp; char *tmpptr, *p; char line[1024]; int lineno = 0; ri.num_alloc = 256; ri.num_used = 0; ri.names = (char **) cp_alloc(ri.num_alloc * sizeof(char *)); ri.numbers = (unsigned long *) cp_alloc(ri.num_alloc * sizeof(unsigned long)); if (nmap_fetchfile(filename, sizeof(filename), "nmap-rpc") != 1) { error("Unable to find nmap-rpc! Resorting to /etc/rpc"); strcpy(filename, "/etc/rpc"); } fp = fopen(filename, "r"); if (!fp) { fatal("Unable to open %s for reading rpc information", filename); } /* Record where this data file was found. */ o.loaded_data_files["nmap-rpc"] = filename; while(fgets(line, sizeof(line), fp)) { lineno++; p = line; if (ri.num_used == ri.num_alloc) { tmpptr = (char *) cp_alloc(ri.num_alloc * 3 * sizeof(char *)); memcpy(tmpptr, ri.names, ri.num_alloc * sizeof(char *)); ri.names = (char **) tmpptr; tmpptr = (char *) cp_alloc(ri.num_alloc * 3 * sizeof(unsigned long)); memcpy(tmpptr, ri.numbers, ri.num_alloc * sizeof(char *)); ri.numbers = (unsigned long *) tmpptr; ri.num_alloc *= 3; } while(*p && *p != '#' && !isalnum((int) (unsigned char) *p)) p++; if (!*p || *p == '#') continue; tmpptr = strpbrk(p, " \t"); if (!tmpptr) continue; *tmpptr = '\0'; ri.names[ri.num_used] = cp_strdup(p); p = tmpptr + 1; while(*p && !isdigit((int) (unsigned char) *p)) p++; if (!*p) continue; ri.numbers[ri.num_used] = strtoul(p, NULL, 10); ri.num_used++; } fclose(fp); return; } char *nmap_getrpcnamebynum(unsigned long num) { int i; rpc_services_init(); for(i=0; i < ri.num_used; i++) { if (ri.numbers[i] == num) return ri.names[i]; } return NULL; } int get_rpc_procs(unsigned long **programs, unsigned long *num_programs) { rpc_services_init(); *programs = ri.numbers; *num_programs = ri.num_used; if (ri.num_used == 0) fatal("Unable to find any valid rpc procedures in your rpc file! RPC scanning won't work for you"); return 0; } /* Send an RPC query to the specified host/port on the specified protocol looking for the specified RPC program. We cache our sending sockets to avoid recreating and (with TCP) reconnect()'ing them each time */ int send_rpc_query(Target *target_host, unsigned short portno, int ipproto, unsigned long program, int scan_offset, int trynum) { static struct sockaddr_storage last_target; struct sockaddr_storage sock; size_t socklen; static int last_ipproto = -1; struct sockaddr_in *sin = NULL, *lastsin = NULL; #ifdef HAVE_IPV6 struct sockaddr_in6 *sin6 = NULL, *lastsin6 = NULL; #endif char rpch_buf[256]; struct rpc_hdr *rpch; int res, err = 0; /* static int numruns = 0; if (numruns++ > 2) fatal("Done"); */ rpch = (struct rpc_hdr *) ((char *)rpch_buf + sizeof(u32)); memset(rpch, 0, sizeof(struct rpc_hdr)); while(rpc_xid_base == (unsigned long) -1) rpc_xid_base = (unsigned long) get_random_uint(); if (o.debugging > 1) { log_write(LOG_PLAIN, "Sending RPC probe for program %li to %hu/%s -- scan_offset=%d trynum=%d xid=%lX\n", program, portno, proto2ascii_lowercase(ipproto), scan_offset, trynum, rpc_xid_base + ((portno & 0x3FFF) << 16) + (trynum << 30) + scan_offset); } memset(&sock, 0, sizeof(sock)); target_host->TargetSockAddr(&sock, &socklen); if (sock.ss_family == AF_INET) { sin = (struct sockaddr_in *) &sock; lastsin = (struct sockaddr_in *) &last_target; sin->sin_port = htons(portno); } #ifdef HAVE_IPV6 else { sin6 = (struct sockaddr_in6 *) &sock; lastsin6 = (struct sockaddr_in6 *) &last_target; sin6->sin6_port = htons(portno); } #endif /* First we check whether we have to create a new connection -- we need to if we have a new target_host, or a new portno, or the socket we want to use is -1 */ if (ipproto == IPPROTO_TCP) { if ((sock.ss_family == AF_INET && memcmp(sin, lastsin, sizeof(struct sockaddr_in))) #ifdef HAVE_IPV6 || (sock.ss_family == AF_INET6 && memcmp(sin6, lastsin6, sizeof(struct sockaddr_in6))) #endif || last_ipproto != IPPROTO_TCP) { /* New host or port -- kill our old tcp socket */ if (tcp_rpc_socket != -1) { close(tcp_rpc_socket); tcp_rpc_socket = -1; tcp_readlen = 0; } } } last_target = sock; last_ipproto = ipproto; if (ipproto == IPPROTO_TCP && tcp_rpc_socket == -1) { if ((tcp_rpc_socket = socket(sock.ss_family, SOCK_STREAM, IPPROTO_TCP)) == -1) pfatal("Socket troubles in %s", __func__); /* I should unblock the socket here and timeout the connect() */ res = connect(tcp_rpc_socket, (struct sockaddr *) &sock, socklen); if (res == -1) { if (o.debugging) { gh_perror("Failed to connect to port %d of %s in %s", portno, target_host->targetipstr(), __func__); } close(tcp_rpc_socket); tcp_rpc_socket = -1; return -1; } unblock_socket(tcp_rpc_socket); } else if (ipproto == IPPROTO_UDP && udp_rpc_socket == -1) { if ((udp_rpc_socket = socket(sock.ss_family, SOCK_DGRAM, 0)) == -1) pfatal("UDP socket troubles in %s", __func__); unblock_socket(udp_rpc_socket); } /* OK, now that we have our sockets together, we form and send a query ... */ rpch->type_msg = htonl(RPC_MSG_CALL); /* rpc request */ rpch->version_rpc=htonl(2); /* portmapper v.2 (hmm, and v3&&4?) */ /*rpch->prog_proc=0;*/ /* proc_null() rpc function */ /*rpch->authcred_flavor=0;*/ /* AUTH_NULL for credentials */ /*rpch->authcred_length=0;*/ /* length of credentials is zero*/ /*rpch->authveri_flavor=0;*/ /* no verifiers field */ /*rpch->authveri_length=0;*/ /* zero length verifier field */ /* Bits are TTPPPPPPPPPPPPPP BBBBBBBBBBBBBBBB */ /* Where T are trynum bits, P is the lowest 14 bits of the port number, and B is the scan[] offset */ rpch->xid = htonl(rpc_xid_base + ((portno & 0x3FFF) << 16) + (trynum << 30) + scan_offset); rpch->prog_id = htonl(program); rpch->prog_ver = htonl(31337 + (rpc_xid_base & 0xFFFFF)); if (ipproto == IPPROTO_UDP) { /* Simply send this sucker we have created ... */ do { if (o.debugging > 1) nmap_hexdump((unsigned char *) rpch, sizeof(struct rpc_hdr)); res = sendto(udp_rpc_socket, (char *)rpch, sizeof(struct rpc_hdr), 0, (struct sockaddr *) &sock, socklen); if (res == -1) err = socket_errno(); } while(res == -1 && (err == EINTR || err == ENOBUFS)); if (res == -1) { if (o.debugging) { gh_perror("Sendto in %s", __func__); close(udp_rpc_socket); udp_rpc_socket = -1; } return -1; } } else { /* TCP socket */ /* 0x80000000 means only 1 record marking */ *(u32 *)rpch_buf = htonl(sizeof(struct rpc_hdr) | 0x80000000); res = Send(tcp_rpc_socket, rpch_buf, sizeof(struct rpc_hdr) + sizeof(u32), 0); if (res == -1) { if (o.debugging) { gh_perror("Write in %s", __func__); } close(tcp_rpc_socket); tcp_rpc_socket = -1; return -1; } } return 0; } static int rpc_are_we_done(char *msg, int msg_len, Target *target, struct portinfo *scan, struct scanstats *ss, struct portinfolist *pil, struct rpcscaninfo *rsi) { struct rpc_hdr_rcv *rpc_pack; unsigned long scan_offset; int trynum; struct portinfo *current; if (rsi->rpc_current_port->state == PORT_OPENFILTERED) { /* Received a packet, so this port is actually open */ target->ports.setPortState(rsi->rpc_current_port->portno, rsi->rpc_current_port->proto, PORT_OPEN); } rpc_pack = (struct rpc_hdr_rcv *) msg; if (msg_len < 24 || msg_len > 32 || (msg_len < 32 && rpc_pack->accept_stat == PROG_MISMATCH)) { /* This is not a valid reply -- we kill the port (from an RPC perspective) */ if (o.debugging > 1) { log_write(LOG_PLAIN, "Port %hu/%s labelled NON_RPC because of invalid sized message (%d)\n", rsi->rpc_current_port->portno, proto2ascii_uppercase(rsi->rpc_current_port->proto), msg_len); } rsi->rpc_status = RPC_STATUS_NOT_RPC; ss->numqueries_outstanding = 0; return 1; } /* Now it is time to decode the scan offset */ scan_offset = ntohl(rpc_pack->xid); scan_offset -= rpc_xid_base; if (((scan_offset >> 16) & 0x3FFF) != (unsigned long) (rsi->rpc_current_port->portno & 0x3FFF)) { /* Doh -- this doesn't seem right */ if (o.debugging > 1) { log_write(LOG_PLAIN, "Port %hu/%s labelled NON_RPC because ((scan_offset >> 16) & 0x3FFF) is %li\n", rsi->rpc_current_port->portno, proto2ascii_uppercase(rsi->rpc_current_port->proto), ((scan_offset >> 16) & 0x3FFF)); } rsi->rpc_status = RPC_STATUS_NOT_RPC; ss->numqueries_outstanding = 0; return 1; } trynum = scan_offset >> 30; scan_offset &= 0xFFFF; if (scan_offset >= rsi->rpc_number) { error("Invalid scan_offset returned in RPC packet"); rsi->rpc_status = RPC_STATUS_NOT_RPC; ss->numqueries_outstanding = 0; return 1; } if (ntohl(rpc_pack->type_msg) != RPC_MSG_REPLY) { error("Strange -- RPC type is %lu should be RPC_MSG_REPLY (1)", (unsigned long) ntohl(rpc_pack->type_msg)); return 0; } if (ntohl(rpc_pack->auth_flavor) != 0 /* AUTH_NULL */ || ntohl(rpc_pack->opaque_length != 0)) { error("Strange -- auth flavor/opaque_length are %lu/%lu should generally be 0/0", (unsigned long) rpc_pack->auth_flavor, (unsigned long) rpc_pack->opaque_length); rsi->rpc_status = RPC_STATUS_NOT_RPC; ss->numqueries_outstanding = 0; return 1; } /* OK, now that we know what this is a response to, we delete the appropriate entry from our scanlist */ current = &scan[scan_offset]; if (current->state != PORT_TESTING && current->state != PORT_CLOSED && current->state != PORT_FILTERED) { error("Supposed scan_offset refers to port in state %s (should be testing, closed, or filtered)", statenum2str(current->state)); rsi->rpc_status = RPC_STATUS_NOT_RPC; ss->numqueries_outstanding = 0; return 1; } if (trynum > current->trynum) { error("Bogus trynum %d when we are only up to %d in %s", trynum, current->trynum, __func__); rsi->rpc_status = RPC_STATUS_NOT_RPC; ss->numqueries_outstanding = 0; return 1; } if (current->next > -1) scan[current->next].prev = current->prev; if (current->prev > -1) scan[current->prev].next = current->next; if (current == pil->testinglist) pil->testinglist = (current->next >= 0)? &scan[current->next] : NULL; current->next = -1; current->prev = -1; /* Adjust timeouts ... */ adjust_timeouts(current->sent[trynum], &(target->to)); /* If a non-zero trynum finds a port that hasn't been discovered, the earlier packets(s) were probably dropped. So we decrease our numqueries_ideal, otherwise we increase it slightly */ if (trynum == 0) { ss->numqueries_ideal = MIN(ss->numqueries_ideal + (ss->packet_incr/ss->numqueries_ideal), ss->max_width); } else { if (!ss->alreadydecreasedqueries) { ss->alreadydecreasedqueries = 1; ss->numqueries_ideal *= ss->fallback_percent; if (ss->numqueries_ideal < 1.0) ss->numqueries_ideal = 1.0; if (o.debugging) { log_write(LOG_STDOUT, "Lost a packet, decreasing window to %d\n", (int) ss->numqueries_ideal); } } } if (current->state == PORT_TESTING) ss->numqueries_outstanding--; if (ntohl(rpc_pack->accept_stat) == PROG_UNAVAIL) { current->state = PORT_CLOSED; if (o.debugging > 1) { error("Port %hu/%s claims that it is not RPC service %li", rsi->rpc_current_port->portno, proto2ascii_uppercase(rsi->rpc_current_port->proto), current->portno); } rsi->valid_responses_this_port++; return 0; } else if (ntohl(rpc_pack->accept_stat) == PROG_MISMATCH) { if (o.debugging > 1) { error("Port %hu/%s claims IT IS RPC service %li", rsi->rpc_current_port->portno, proto2ascii_uppercase(rsi->rpc_current_port->proto), current->portno); } current->state = PORT_OPEN; rsi->rpc_status = RPC_STATUS_GOOD_PROG; rsi->rpc_program = current->portno; rsi->rpc_lowver = ntohl(rpc_pack->low_version); rsi->rpc_highver = ntohl(rpc_pack->high_version); rsi->valid_responses_this_port++; ss->numqueries_outstanding = 0; return 1; } else if (ntohl(rpc_pack->accept_stat) == SUCCESS) { error("Umm -- RPC returned success for bogus version -- thats OK I guess"); rsi->rpc_status = RPC_STATUS_GOOD_PROG; rsi->rpc_program = current->portno; rsi->rpc_lowver = rsi->rpc_highver = 0; rsi->valid_responses_this_port++; ss->numqueries_outstanding = 0; return 1; } else { fatal("Illegal rpc accept_stat"); } return 0; } static unsigned short sockaddr_port(const struct sockaddr_storage *ss) { unsigned short port; if (ss->ss_family == AF_INET) port = ((struct sockaddr_in *) ss)->sin_port; else if (ss->ss_family == AF_INET6) port = ((struct sockaddr_in6 *) ss)->sin6_port; else port = 0; return ntohs(port); } void get_rpc_results(Target *target, struct portinfo *scan, struct scanstats *ss, struct portinfolist *pil, struct rpcscaninfo *rsi) { int max_sd = -1; fd_set fds_r; int sres; struct timeval tv; int res; static char readbuf[512]; char *current_msg; unsigned long current_msg_len; if ((udp_rpc_socket == -1 && tcp_rpc_socket == -1) || ss->numqueries_outstanding <= 0) return; FD_ZERO(&fds_r); if (udp_rpc_socket >= 0 && rsi->rpc_current_port->proto == IPPROTO_UDP) { FD_SET(udp_rpc_socket, &fds_r); max_sd = udp_rpc_socket; } else if (tcp_rpc_socket >= 0 && rsi->rpc_current_port->proto == IPPROTO_TCP) { FD_SET(tcp_rpc_socket, &fds_r); max_sd = tcp_rpc_socket; } else { error("Unable to find listening socket in %s", __func__); return; } while (ss->numqueries_outstanding > 0) { /* Insure there is no timeout ... */ gettimeofday(&tv, NULL); if (target->timedOut(&tv)) return; tv.tv_sec = target->to.timeout / 1000000; tv.tv_usec = target->to.timeout % 1000000; sres = select(max_sd + 1, &fds_r, NULL, NULL, &tv); if (!sres) break; if (sres == -1 && socket_errno() == EINTR) continue; if (udp_rpc_socket >= 0 && FD_ISSET(udp_rpc_socket, &fds_r)) { struct sockaddr_storage from; recvfrom6_t fromlen = sizeof(from); unsigned short fromport; res = recvfrom(udp_rpc_socket, readbuf, sizeof(readbuf), 0, (struct sockaddr *) &from, &fromlen); if (res < 0) { /* Doh! */ if (o.debugging || o.verbose) gh_perror("recvfrom in %s", __func__); ss->numqueries_outstanding = 0; rsi->rpc_status = RPC_STATUS_NOT_RPC; return; } fromport = sockaddr_port(&from); if (o.debugging > 1) log_write(LOG_PLAIN, "Received %d byte UDP packet\n", res); /* Now we check that the response is from the expected host/port */ if (!sockaddr_storage_equal(&from, target->TargetSockAddr()) || fromport != rsi->rpc_current_port->portno) { if (o.debugging > 1) { log_write(LOG_PLAIN, "Received UDP packet from %s/%hu", inet_ntop_ez(&from, fromlen), fromport); log_write(LOG_PLAIN, " when expecting packet from %s/%hu\n", target->targetipstr(), rsi->rpc_current_port->portno); } continue; } if (rpc_are_we_done(readbuf, res, target, scan, ss, pil, rsi) != 0) { return; } } else if (tcp_rpc_socket >= 0 && FD_ISSET(tcp_rpc_socket, &fds_r)) { do { res = recv(tcp_rpc_socket, readbuf + tcp_readlen, sizeof(readbuf) - tcp_readlen, 0); } while(res == -1 && socket_errno() == EINTR); if (res <= 0) { if (o.debugging) { if (res == -1) gh_perror("Failed to read() from tcp rpc socket in %s", __func__); else { error("Lamer on port %u closed RPC socket on me in %s", rsi->rpc_current_port->portno, __func__); } } ss->numqueries_outstanding = 0; rsi->rpc_status = RPC_STATUS_NOT_RPC; return; } tcp_readlen += res; if (tcp_readlen < 28) { /* This is suspiciously small -- I'm assuming this is not the first part of a valid RPC packet */ if (o.debugging > 1) { log_write(LOG_PLAIN, "Port %hu/%s labelled NON_RPC because tcp_readlen is %d (should be at least 28)\n", rsi->rpc_current_port->portno, proto2ascii_uppercase(rsi->rpc_current_port->proto), (int) tcp_readlen); } ss->numqueries_outstanding = 0; rsi->rpc_status = RPC_STATUS_NOT_RPC; return; } /* I'm ignoring the multiple msg fragment possibility for now */ current_msg_len = ntohl((*(unsigned long *)readbuf)) & 0x7FFFFFFF; if (current_msg_len > tcp_readlen - 4) { if (o.debugging > 1) { log_write(LOG_PLAIN, "Port %hu/%s labelled NON_RPC because current_msg_len is %li while tcp_readlen is %d\n", rsi->rpc_current_port->portno, proto2ascii_uppercase(rsi->rpc_current_port->proto), current_msg_len, (int) tcp_readlen); } ss->numqueries_outstanding = 0; rsi->rpc_status = RPC_STATUS_NOT_RPC; return; } current_msg = readbuf + 4; do { if (rpc_are_we_done(current_msg, current_msg_len, target, scan, ss, pil, rsi) != 0) return; current_msg += current_msg_len; if ((current_msg - readbuf) + 4UL < tcp_readlen) { current_msg_len = ntohl(*(unsigned long *) current_msg) & 0x7FFFFFFF; current_msg += 4; } else { if ((unsigned long) (current_msg - readbuf) < tcp_readlen) { tcp_readlen -= current_msg - readbuf; memmove(readbuf, current_msg, tcp_readlen); } else tcp_readlen = 0; break; } if (current_msg_len < 24 || current_msg_len > 32) { ss->numqueries_outstanding = 0; if (o.debugging > 1) { log_write(LOG_PLAIN, "Port %hu/%s labelled NON_RPC because current_msg_len is %li\n", rsi->rpc_current_port->portno, proto2ascii_uppercase(rsi->rpc_current_port->proto), current_msg_len); } rsi->rpc_status = RPC_STATUS_NOT_RPC; return; } if ((current_msg - readbuf) + current_msg_len > tcp_readlen) { tcp_readlen -= current_msg - readbuf; memmove(readbuf +4 , current_msg, tcp_readlen); *(unsigned long *)&readbuf = htonl(current_msg_len); tcp_readlen += 4; break; } } while(1); } } return; } void close_rpc_query_sockets() { if (udp_rpc_socket != -1) { close(udp_rpc_socket); udp_rpc_socket = -1; } if (tcp_rpc_socket != -1) { close(tcp_rpc_socket); tcp_rpc_socket = -1; } }