static gint socket_fd_connect_inet(gushort port) { SOCKET sock; struct sockaddr_in addr; sock = socket(AF_INET, SOCK_STREAM, 0); if (G_UNLIKELY(! SOCKET_IS_VALID(sock))) { log_error("Failed to create IPC socket", -1); return -1; } memset(&addr, 0, sizeof(addr)); addr.sin_family = AF_INET; addr.sin_port = htons(port); addr.sin_addr.s_addr = htonl(INADDR_LOOPBACK); if (connect(sock, (struct sockaddr *)&addr, sizeof(addr)) < 0) { gint saved_errno = WSAGetLastError(); gchar* message = g_strdup_printf("Failed to connect to IPC socket (127.0.0.1:%d)", port); log_error(message, saved_errno); g_free(message); socket_fd_close(sock); return -1; } return sock; }
static gint socket_fd_connect_inet(gushort port) { SOCKET sock; struct sockaddr_in addr; sock = socket(AF_INET, SOCK_STREAM, 0); if (G_UNLIKELY(! SOCKET_IS_VALID(sock))) { geany_debug("fd_connect_inet(): socket() failed: %d\n", WSAGetLastError()); return -1; } memset(&addr, 0, sizeof(addr)); addr.sin_family = AF_INET; addr.sin_port = htons(port); addr.sin_addr.s_addr = htonl(INADDR_LOOPBACK); if (connect(sock, (struct sockaddr *)&addr, sizeof(addr)) < 0) { socket_fd_close(sock); return -1; } return sock; }
gint fd_connect_inet(gushort port) { SockDesc sock; struct sockaddr_in addr; sock = socket(AF_INET, SOCK_STREAM, 0); if (!SOCKET_IS_VALID(sock)) { #ifdef G_OS_WIN32 g_warning("fd_connect_inet(): socket() failed: %ld\n", WSAGetLastError()); #else perror("fd_connect_inet(): socket"); #endif return -1; } memset(&addr, 0, sizeof(addr)); addr.sin_family = AF_INET; addr.sin_port = htons(port); addr.sin_addr.s_addr = htonl(INADDR_LOOPBACK); if (connect(sock, (struct sockaddr *)&addr, sizeof(addr)) < 0) { fd_close(sock); return -1; } return sock; }
SockInfo *sock_connect(const gchar *hostname, gushort port) { SockDesc sock; SockInfo *sockinfo; #ifdef INET6 sock = sock_connect_by_getaddrinfo(hostname, port); if (!SOCKET_IS_VALID(sock)) return NULL; #else sock = socket(AF_INET, SOCK_STREAM, 0); if (!SOCKET_IS_VALID(sock)) { #ifdef G_OS_WIN32 g_warning("socket() failed: %ld\n", WSAGetLastError()); #else perror("socket"); #endif /* G_OS_WIN32 */ return NULL; } sock_set_buffer_size(sock); if (sock_connect_by_hostname(sock, hostname, port) < 0) { if (errno != 0) perror("connect"); fd_close(sock); return NULL; } #endif /* INET6 */ sockinfo = g_new0(SockInfo, 1); sockinfo->sock = sock; sockinfo->sock_ch = g_io_channel_unix_new(sock); sockinfo->hostname = g_strdup(hostname); sockinfo->port = port; sockinfo->state = CONN_ESTABLISHED; sockinfo->flags = SYL_SOCK_CHECK_IO; sock_list = g_list_prepend(sock_list, sockinfo); g_usleep(100000); return sockinfo; }
static gint socket_fd_open_inet(gushort port) { SOCKET sock; struct sockaddr_in addr; gchar val; sock = socket(AF_INET, SOCK_STREAM, 0); if (G_UNLIKELY(! SOCKET_IS_VALID(sock))) { log_error("Failed to create IPC socket", -1); return -1; } val = 1; if (setsockopt(sock, SOL_SOCKET, SO_EXCLUSIVEADDRUSE, &val, sizeof(val)) < 0) { log_error("Failed to set IPC socket exclusive option", -1); socket_fd_close(sock); return -1; } memset(&addr, 0, sizeof(addr)); addr.sin_family = AF_INET; addr.sin_port = htons(port); addr.sin_addr.s_addr = htonl(INADDR_LOOPBACK); if (bind(sock, (struct sockaddr *)&addr, sizeof(addr)) < 0) { gint saved_errno = WSAGetLastError(); gchar* message = g_strdup_printf("Failed to bind IPC socket (127.0.0.1:%d)", port); log_error(message, saved_errno); g_free(message); socket_fd_close(sock); return -1; } if (listen(sock, 1) < 0) { gint saved_errno = WSAGetLastError(); gchar* message = g_strdup_printf("Failed to listen on IPC socket (127.0.0.1:%d)", port); log_error(message, saved_errno); g_free(message); socket_fd_close(sock); return -1; } return sock; }
static SockDesc sock_connect_by_getaddrinfo(const gchar *hostname, gushort port) { SockDesc sock = INVALID_SOCKET; gint gai_error; struct addrinfo hints, *res, *ai; gchar port_str[6]; resolver_init(); memset(&hints, 0, sizeof(hints)); /* hints.ai_flags = AI_CANONNAME; */ hints.ai_family = AF_UNSPEC; hints.ai_socktype = SOCK_STREAM; hints.ai_protocol = IPPROTO_TCP; /* convert port from integer to string. */ g_snprintf(port_str, sizeof(port_str), "%d", port); if ((gai_error = getaddrinfo(hostname, port_str, &hints, &res)) != 0) { fprintf(stderr, "getaddrinfo for %s:%s failed: %s\n", hostname, port_str, gai_strerror(gai_error)); return INVALID_SOCKET; } for (ai = res; ai != NULL; ai = ai->ai_next) { sock = socket(ai->ai_family, ai->ai_socktype, ai->ai_protocol); if (!SOCKET_IS_VALID(sock)) continue; sock_set_buffer_size(sock); if (sock_connect_with_timeout (sock, ai->ai_addr, ai->ai_addrlen, io_timeout) == 0) break; fd_close(sock); } if (res != NULL) freeaddrinfo(res); if (ai == NULL) return INVALID_SOCKET; return sock; }
gint fd_open_inet(gushort port) { SockDesc sock; struct sockaddr_in addr; gint val; sock = socket(AF_INET, SOCK_STREAM, 0); if (!SOCKET_IS_VALID(sock)) { #ifdef G_OS_WIN32 g_warning("fd_open_inet(): socket() failed: %ld\n", WSAGetLastError()); #else perror("fd_open_inet(): socket"); #endif return -1; } val = 1; if (setsockopt(sock, SOL_SOCKET, SO_REUSEADDR, (char *)&val, sizeof(val)) < 0) { perror("setsockopt"); fd_close(sock); return -1; } memset(&addr, 0, sizeof(addr)); addr.sin_family = AF_INET; addr.sin_port = htons(port); addr.sin_addr.s_addr = htonl(INADDR_LOOPBACK); if (bind(sock, (struct sockaddr *)&addr, sizeof(addr)) < 0) { perror("bind"); fd_close(sock); return -1; } if (listen(sock, 1) < 0) { perror("listen"); fd_close(sock); return -1; } return sock; }
static gint socket_fd_open_inet(gushort port) { SOCKET sock; struct sockaddr_in addr; gchar val; sock = socket(AF_INET, SOCK_STREAM, 0); if (G_UNLIKELY(! SOCKET_IS_VALID(sock))) { geany_debug("fd_open_inet(): socket() failed: %d\n", WSAGetLastError()); return -1; } val = 1; if (setsockopt(sock, SOL_SOCKET, SO_REUSEADDR, &val, sizeof(val)) < 0) { perror("setsockopt"); socket_fd_close(sock); return -1; } memset(&addr, 0, sizeof(addr)); addr.sin_family = AF_INET; addr.sin_port = htons(port); addr.sin_addr.s_addr = htonl(INADDR_LOOPBACK); if (bind(sock, (struct sockaddr *)&addr, sizeof(addr)) < 0) { perror("bind"); socket_fd_close(sock); return -1; } if (listen(sock, 1) < 0) { perror("listen"); socket_fd_close(sock); return -1; } return sock; }
static void query_names(FILE *ofp, SOCKET sockfd) { short seq = 1000; int npending = 0; struct in_addr next_addr; int have_next_addr = FALSE; char errbuf[256]; assert( ofp != 0 ); assert( SOCKET_IS_VALID(sockfd) ); /*---------------------------------------------------------------- * Figure out our starting and ending addresses to be scanning. * These are treated as simple long integers that are incremented * on each loop, and we must have at least one loop to be valid. */ while ( have_next_addr || ((have_next_addr = next_target(&next_addr)) != 0) || (npending > 0) ) { fd_set rfds, /* list of read descriptors */ wfds, /* list of write descriptors */ *pwfds = 0; int n; struct timeval tv; /*-------------------------------------------------------- * Our select is just a bit tricky. We always are waiting * on the read channel, but we only want to wait on the * write channel if there are any more addresses in our * list to process. After we've sent all the packets to * the other end, we stop writing and do only reading. */ FD_ZERO(&rfds); FD_SET(sockfd, &rfds); timeval_set_secs(&tv, timeout_secs); if ( have_next_addr ) { wfds = rfds; pwfds = &wfds; } if ( (n = select(sockfd+1, &rfds, pwfds, 0, &tv)) == 0 ) { fprintf(stderr, "*timeout (normal end of scan)\n"); fflush(ofp); break; } else if ( n < 0) { printf("ERROR [%s]\n", strerror(errno)); break; } /*-------------------------------------------------------- * Has the read descriptor fired? */ if ( n > 0 && FD_ISSET(sockfd, &rfds) ) { int paklen; struct sockaddr_in src; struct NMBpacket pak; struct NMB_query_response rsp; memset(&src, 0, sizeof src); memset(&rsp, 0, sizeof rsp); paklen = (int)recvpacket(sockfd, &pak, sizeof pak,&src); if ( verbose ) { if ( paklen < 0 ) { fprintf(ofp, "Error on read: %s\n", strerror(errno)); } else { fprintf(ofp, "Got %d bytes from %s\n", paklen, inet_ntoa(src.sin_addr) ); if ( verbose > 1 ) dump_nbtpacket(&pak, paklen, stdout); } } /*------------------------------------------------ * If we actually got something from the other end, * parse the response, plug in the remote's IP addr, * and display it. */ if ( paklen <= 0 ) continue; npending--; if ( parse_nbtstat(&pak, paklen, &rsp, errbuf) ) { rsp.remote = src; if ( target_responded(&rsp.remote.sin_addr) ) { #ifdef ENABLE_PERL if ( gen_Perl ) generate_perl(ofp, &rsp); else #endif display_nbtstat(ofp,&rsp,full_nbtstat); } } else { fprintf(ofp, "ERROR: no parse for %s -- %s\n", inet_ntoa(src.sin_addr), errbuf); } } /*-------------------------------------------------------- * If we have room to write one packet, do so here. Note * that we make not notice whether the write succeeds or * not: we don't care. */ if ( n > 0 && pwfds && FD_ISSET(sockfd, pwfds) ) { struct sockaddr_in dst; struct NMBpacket pak; int sendlen; memset(&dst, 0, sizeof dst); dst.sin_family = AF_INET; dst.sin_addr.s_addr = next_addr.s_addr; dst.sin_port = htons(dest_portno); have_next_addr = FALSE; fill_namerequest(&pak, &sendlen, seq++); if ( verbose ) { fprintf(ofp, "sending to %s\n", inet_ntoa(dst.sin_addr)); } /* yes, ignore response! */ (void) sendpacket(sockfd, &pak, sendlen, &dst); if ( write_sleep_msecs > 0 ) sleep_msecs(write_sleep_msecs); npending++; continue; } } }
/*------------------------------------------------------------------------ * Set the Usage information for the user... */ int main(int argc, char **argv) { FILE *ofp = 0; const char *outfile = 0; SOCKET sockfd; int c; char errbuf[256]; struct sockaddr_in myaddr; int have_targets = FALSE; #ifdef _WIN32 int winsock_level = 2; #endif /* quick hack */ if ( argv[1] && strcmp(argv[1], "--version") == 0 ) { puts(Version); exit(EXIT_SUCCESS); } while ( (c = getopt(argc, argv, "CHT:nfp:bt:vw:mVO:1P")) != EOF ) { switch (c) { default: Usage(argv[0]); case 'P': #ifdef ENABLE_PERL gen_Perl = TRUE; #else die("Sorry, -P perl support not compiled"); #endif break; case 'C': #ifdef SUPPORT_CIFS dest_portno = 445; break; #else die("Sorry, -C not supported yet"); #endif case '1': #ifdef _WIN32 winsock_level = 1; #endif break; case 'H': gen_HTTP = TRUE; break; case 'O': outfile = optarg; break; case 't': set_tries( atoi(optarg) ); break; case 'V': puts(Version); exit(EXIT_SUCCESS); case 'm': show_mac_address = TRUE; break; case 'f': full_nbtstat = TRUE; break; case 'p': bind_portno = (unsigned short)atoi(optarg); break; case 'b': #if SUPPORT_BROADCAST broadcast = TRUE; break; #else die("Sorry, -b broadcast not yet supported"); #endif case 'v': verbose++; break; case 'T': timeout_secs = atoi(optarg); break; case 'w': write_sleep_msecs = atoi(optarg); break; case 'n': no_inverse_lookup = TRUE; break; } } if ( outfile != 0 ) ofp = fopen(outfile, "w"); if ( ofp == 0 ) ofp = stdout; if ( gen_HTTP ) printf("Content-type: text/plain\n\n"); #if _WIN32 init_winsock(verbose, winsock_level); #endif /*---------------------------------------------------------------- * Run through the rest of the command line parsing the various * target specifications. Each one specifies one or more targets * that we're to scan, and each one gets linked into the end of * the current chain. */ while ( optind < argc ) { const char *arg = argv[optind++]; if ( ! parse_target_range(arg, errbuf) ) die("ERROR: invalid target specification: %s", errbuf); have_targets++; } if ( ! have_targets ) Usage(argv[0]); sockfd = socket(PF_INET, SOCK_DGRAM, 0); if ( ! SOCKET_IS_VALID(sockfd) ) { die("ERROR: cannot create socket [%s]", NATIVE_ERROR); } /*---------------------------------------------------------------- * Some systems require that we specifically enable broadcast on * the local network: do so if requested. It doesn't seem to work * very well. */ #if ENABLE_BROADCAST if ( broadcast ) { int b = 1; int rc; rc = setsockopt(sockfd, SOL_SOCKET, SO_BROADCAST, (char *)&b, sizeof b); if ( rc != 0 ) { die("ERROR: can't set SO_BROADCAST [%s]", NATIVE_ERROR); } } #endif /*---------------------------------------------------------------- * Bind the local endpoint to receive our responses. If we use a * zero, the system will pick one for us, or we can pick our own * if we wish to make it easier to get past our firewall. */ memset(&myaddr, 0, sizeof myaddr); myaddr.sin_family = AF_INET; myaddr.sin_addr.s_addr = htonl(INADDR_ANY); myaddr.sin_port = htons(bind_portno); if ( bind_in(sockfd, &myaddr) != 0 ) #ifdef _WIN32 die("ERROR: cannot bind to local socket [%ld]", WSAGetLastError()); #else die("ERROR: cannot bind to local socket [%s]", strerror(errno)); #endif if ( verbose ) { fprintf(ofp, "Bound to %s.%d\n", inet_ntoa( myaddr.sin_addr), ntohs( myaddr.sin_port)); } #ifdef ENABLE_PERL if ( gen_Perl ) start_perl(ofp, argv); #endif query_names(ofp, sockfd); #ifdef ENABLE_PERL if ( gen_Perl ) end_perl(ofp); #endif #if _WIN32 WSACleanup(); #endif return 0; }