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;
}
