onesixtyone-0.3.2/0042755000175000017500000000000007776161263014035 5ustar slunchoslunchoonesixtyone-0.3.2/onesixtyone.c0100644000175000017500000004514007776161012016554 0ustar slunchosluncho/* onesixtyone version 0.3.2 Copyright (C) 2002,2003 solareclipse@phreedom.org This program is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation; either version 2 of the License, or (at your option) any later version. 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 for more details. You should have received a copy of the GNU General Public License along with this program; if not, write to the Free Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ #include #include #include #include #include #include #include #include #include #include #include #ifndef INADDR_NONE /* Solaris is broken */ #define INADDR_NONE -1 #endif #define MAX_COMMUNITIES 1024 #define MAX_HOSTS 65535 #define MAX_COMMUNITY_SIZE 16 char* snmp_errors[] = { "NO ERROR", /* 0 */ "TOO BIG", /* 1 */ "NO SUCH NAME", /* 2 */ "BAD VALUE", /* 3 */ "READ ONLY", /* 4 */ "GENERIC ERROR", /* 5 */ "NO ACCESS", /* 6 */ "WRONG TYPE", /* 7 */ "WRONG LENGTH", /* 8 */ "WRONG ENCODING", /* 9 */ "WRONG VALUE", /* 10 */ "NO CREATION", /* 11 */ "INCONSISTENT VALUE", /* 12 */ "RESOURCE UNAVAILABLE", /* 13 */ "COMMIT FAILED", /* 14 */ "UNDO FAILED", /* 15 */ "AUTHORIZATION ERROR", /* 16 */ "NOT WRITABLE", /* 17 */ "INCONSISTENT NAME", /* 18 */ }; struct { int debug; int log; int quiet; long wait; FILE* log_fd; } o; int community_count = 2; char* community[MAX_COMMUNITIES] = { "public", "private" }; int host_count = 0; struct { int addr; char* sysDescr; /* char* communities[];*/ } host[MAX_HOSTS]; void usage() { printf("onesixtyone 0.3.2 [options] \n"); printf(" -c file with community names to try\n"); printf(" -i file with target hosts\n"); printf(" -o output log\n"); printf(" -d debug mode, use twice for more information\n\n"); printf(" -w n wait n milliseconds (1/1000 of a second) between sending packets (default 10)\n"); printf(" -q quiet mode, do not print log to stdout, use with -l\n"); printf("examples: ./s -c dict.txt 192.168.4.1 public\n"); printf(" ./s -c dict.txt -i hosts -o my.log -w 100\n\n"); } void read_communities(char* filename) { FILE* fd; int i, c; char ch; if (o.debug > 0) printf("Using community file %s\n", filename); if ((fd = fopen(filename, "r")) == 0) { printf("Error opening community file %s\n", filename); exit(1); } i = 0; c = 0; community[i] = (char*)malloc(MAX_COMMUNITY_SIZE); while ((ch = fgetc(fd)) != EOF) { if (ch == '\n' || ch == ' ' || ch == '\t') { community[i][c] = '\0'; if (c > 0) { i++; c = 0; community[i] = (char*)malloc(16); } } else { community[i][c++] = ch; } if (c > MAX_COMMUNITY_SIZE-1) { printf("Community string too long\n"); exit(1); } } community_count = i; fclose(fd); } void read_hosts(char* filename) { FILE* fd; char buf[100]; char ch; int c; if (strcmp(filename, "-") == 0) { if (o.debug > 0) printf("Reading hosts from stdin\n"); fd = stdin; } else { if (o.debug > 0) printf("Reading hosts from input file %s\n", filename); if ((fd = fopen(filename, "r")) == 0) { printf("Error opening input file %s\n", filename); exit(1); } } host_count = 0; c = 0; ch = 0; while ((ch = fgetc(fd)) != EOF) { if (ch == '\n' || ch == ' ' || ch == '\t') { buf[c] = '\0'; if (c > 0) { /* skip blank lines */ if ((host[host_count++].addr = inet_addr((const char*)&buf)) == INADDR_NONE) { printf("Malformed IP address: %s\n", buf); exit(1); } c = 0; } } else { buf[c++] = ch; } if (c > sizeof(buf)-1) { printf("IP address too long\n"); exit(1); } } if (fd != stdin) fclose(fd); if (o.debug > 0) printf("%d hosts read from file\n", host_count); } void init_options(int argc, char *argv[]) { char community_filename[250]; char input_filename[250]; char log_filename[255]; int input_file; int community_file; int arg, i; o.debug = 0; o.log = 0; o.quiet = 0; o.wait = 10; input_file = 0; community_file = 0; o.log_fd = NULL; while ((arg = getopt(argc, argv, "c:di:o:w:q")) != EOF) { switch (arg) { case 'c' : community_file = 1; strncpy(community_filename, optarg, sizeof(community_filename)); break; case 'd' : o.debug++; break; case 'i' : input_file = 1; strncpy(input_filename, optarg, sizeof(input_filename)); break; case 'o' : o.log = 1; strncpy(log_filename, optarg, sizeof(log_filename)); break; case 'w' : o.wait = atol(optarg); /* convert to nanoseconds */ break; case 'q' : o.quiet = 1; break; case '?' : usage(); exit(1); break; } } if (o.debug) { if (o.debug > 0) printf("Debug level %d\n", o.debug); } if (!input_file) { if (optind >= argc) { usage(); exit(1); } if ((host[0].addr = inet_addr((const char*)argv[optind++])) == INADDR_NONE) { printf("Malformed IP address: %s\n", argv[optind-1]); exit(1); } host_count = 1; if (o.debug > 0) printf("Target ip read from command line: %s\n", argv[optind-1]); } else { read_hosts((char*)&input_filename); } if (community_file) { read_communities((char*)&community_filename); } if (optind < argc) { if (community_file) { usage(); exit(1); } community[0] = argv[optind++]; community_count = 1; if (o.debug > 0) printf("Community read from command line: %s\n", community[0]);; } if (optind < argc) { usage(); exit(1); } if (o.log) { if ((o.log_fd = fopen(log_filename, "w")) == 0) { printf("Error opening log file %s\n", log_filename); exit(1); } printf("Logging to file %s\n", log_filename); } else if (o.quiet) { printf("Warning: quiet mode specified without logging, you will lose your scan results\n"); } if (o.debug > 0) { printf("%d communities:", community_count); for (i=0; i < community_count; i++) printf(" %s", community[i]); printf("\n"); } if (o.debug > 0) printf("Waiting for %ld milliseconds between packets\n", o.wait); } int build_snmp_req(char* buf, int buf_size, char* community) { int i; static int id; char object[] = "\x30\x0e\x30\x0c\x06\x08\x2b\x06\x01\x02\x01\x01\x01\x0\x05\x00"; if (21 + strlen(community) + strlen(object) > buf_size) { printf("SNMP packet length exceeded.\nCommunity: %s\nObject: %s\n", community, object); exit(1); } if (--id > 0x7ffe) id = 0; memset(buf, 0, buf_size); buf[0] = 0x30; buf[1] = 19 + strlen(community) + sizeof(object)-1; // Version: 1 buf[2] = 0x02; buf[3] = 0x01; buf[4] = 0x00; // Community buf[5] = 0x04; buf[6] = strlen(community); strcpy((buf + 7), community); i = 7 + strlen(community); // PDU type: GET buf[i++] = 0xa0; buf[i++] = 12 + sizeof(object)-1; // Request ID buf[i++] = 0x02; buf[i++] = 0x04; buf[i++] = (char)((id >> 24) & 0xff); buf[i++] = (char)((id >> 16) & 0xff); buf[i++] = (char)((id >> 8) & 0xff); buf[i++] = (char)((id >> 0) & 0xff); // Error status: no error buf[i++] = 0x02; buf[i++] = 0x01; buf[i++] = 0x00; // Error index buf[i++] = 0x02; buf[i++] = 0x01; buf[i++] = 0x00; // Object ID memcpy((char*)&buf[i], &object, sizeof(object)-1); i = i + sizeof(object)-1; return (i); } void logf(char* fmt, ...) { va_list args; va_start(args, fmt); if (o.log) vfprintf(o.log_fd, fmt, args); if (!o.quiet) vprintf(fmt, args); va_end(args); } int parse_asn_length(u_char* buf, int buf_size, int* i) { int len; if (*i >= buf_size) { logf("Unable to decode SNMP packet: buffer overflow\n"); return -1; } if (buf[*i] < 0x81) { len = buf[*i]; *i += 1; } else if (buf[*i] == 0x81) { *i += 1; if ((*i)+1 > buf_size) { logf("Unable to decode SNMP packet: buffer overflow\n"); return -1; } len = buf[*i]; *i += 1; } else if (buf[*i] == 0x82) { *i += 1; if ((*i)+2 > buf_size) { logf("Unable to decode SNMP packet: buffer overflow\n"); return -1; } len = (buf[*i] << 8) + buf[(*i)+1]; *i += 2; } else if (buf[*i] == 0x83) { *i += 1; if ((*i)+3 > buf_size) { logf("Unable to decode SNMP packet: buffer overflow\n"); return -1; } len = (buf[*i] << 16) + (buf[(*i)+1] << 8) + buf[(*i)+2]; *i += 3; } else if (buf[*i] == 0x84) { *i += 1; if ((*i)+4 > buf_size) { logf("Unable to decode SNMP packet: buffer overflow\n"); return -1; } len = (buf[*i] << 24) + (buf[(*i)+1] << 16) + (buf[(*i)+2] << 8) + buf[(*i)+3]; *i += 4; } else { logf("Unable to decode SNMP packet: wrong length\n"); return -1; } if ((*i)+len > buf_size) { logf("Unable to decode SNMP packet: buffer overflow\n"); return -1; } return len; } int skip_asn_length(u_char* buf, int buf_size, int* i) { int ret; if ((ret = parse_asn_length(buf, buf_size, i)) > 0) *i += ret; return ret; } int parse_asn_integer(u_char* buf, int buf_size, int* i) { int ret; if (*i >= buf_size) { logf("Unable to decode SNMP packet: buffer overflow\n"); return -1; } if (buf[*i] == 0x81) { *i += 1; if (*i >= buf_size) { logf("Unable to decode SNMP packet: buffer overflow\n"); return -1; } } if (buf[*i] == 0x01) { if ((*i)+2 > buf_size) { logf("Unable to decode SNMP packet: buffer overflow\n"); return -1; } ret = (int)buf[(*i)+1]; *i += 2; } else if (buf[*i] == 0x02) { if ((*i)+3 > buf_size) { logf("Unable to decode SNMP packet: buffer overflow\n"); return -1; } ret = ((int)buf[(*i)+1] << 8) + (int)buf[(*i)+2]; *i += 3; } else if (buf[*i] == 0x04) { if ((*i)+5 > buf_size) { logf("Unable to decode SNMP packet: buffer overflow\n"); return -1; } ret = ((int)buf[(*i)+1] << 24) + ((int)buf[(*i)+2] << 16) + ((int)buf[(*i)+3] << 8) + (int)buf[(*i)+4]; *i += 5; } else { logf("Unable to decode SNMP packet: unrecognized integer length\n"); return -1; } return ret; } int print_asn_string(u_char* buf, int buf_size, int* i) { int ret; int string_end; if ((ret = parse_asn_length(buf, buf_size, i)) == -1) return -1; else string_end = *i + ret; for (;*i < string_end; *i += 1) { if (buf[*i] < 0x20 || buf[*i] > 0x80) logf(" "); else logf("%c", buf[*i]); } return 0; } int parse_snmp_header(u_char* buf, int buf_size, int* i) { if (*i >= buf_size) { logf("Unable to decode SNMP packet: buffer overflow\n"); return -1; } if (buf[(*i)++] != 0x30) { logf("Unable to decode SNMP packet: wrong header\n"); return -1; } if (parse_asn_length(buf, buf_size, i) < 0) return -1; return 0; } int parse_snmp_version(u_char* buf, int buf_size, int* i) { int ret; if (*i >= buf_size) { logf("Unable to decode SNMP packet: buffer overflow\n"); return -1; } if (buf[(*i)++] != 0x02) { logf("Unable to decode SNMP packet: snmp version invalid\n"); return -1; } if ((ret = parse_asn_integer(buf, buf_size, i)) == -1) return -1; else if (ret != 0) { logf("Unable to decode SNMP packet: snmp version invalid\n"); return -1; } return 0; } int parse_snmp_community(u_char* buf, int buf_size, int* i) { if (*i >= buf_size) { logf("Unable to decode SNMP packet: buffer overflow\n"); return -1; } if (buf[(*i)++] != 0x04) { logf("Unable to decode SNMP packet: community name not found\n"); return -1; } logf("["); if (print_asn_string(buf, buf_size, i) == -1) return -1; logf("] "); return 0; } int parse_snmp_pdu(u_char* buf, int buf_size, int* i) { if (*i >= buf_size) { logf("Unable to decode SNMP packet: buffer overflow\n"); return -1; } if (buf[(*i)++] != 0xa2) { logf("Unable to decode SNMP packet: PDU type not RESPONSE (0xa2)\n"); return -1; } if (parse_asn_length(buf, buf_size, i) < 0) return -1; return 0; } int parse_snmp_requestid(u_char* buf, int buf_size, int* i) { if (*i >= buf_size) { logf("Unable to decode SNMP packet: buffer overflow\n"); return -1; } if (buf[(*i)++] != 0x02) { logf("Unable to decode SNMP packet: request id invalid\n"); return -1; } if (parse_asn_integer(buf, buf_size, i) < 0) return -1; return 0; } int parse_snmp_errorcode(u_char* buf, int buf_size, int* i) { int ret; if (*i >= buf_size) { logf("Unable to decode SNMP packet: buffer overflow\n"); return -1; } if (buf[(*i)++] != 0x02) { logf("Unable to decode SNMP packet: error code invalid\n"); return -1; } if ((ret = parse_asn_integer(buf, buf_size, i)) < 0) return -1; if (ret != 0) { if (ret < 0 || ret > 18) { logf("Unable to decode SNMP packet: error code invalid\n"); return -1; } logf("Host responded with error %s\n", snmp_errors[ret]); return -1; } return 0; } int parse_snmp_errorindex(u_char* buf, int buf_size, int* i) { if (*i >= buf_size) { logf("Unable to decode SNMP packet: buffer overflow\n"); return -1; } if (buf[(*i)++] != 0x02) { logf("Unable to decode SNMP packet: error index invalid\n"); return -1; } if (parse_asn_integer(buf, buf_size, i) < 0) return -1; return 0; } int parse_snmp_objheader(u_char* buf, int buf_size, int* i) { if (*i >= buf_size) { logf("Unable to decode SNMP packet: buffer overflow\n"); return -1; } if (buf[(*i)++] != 0x30) { logf("Unable to decode SNMP packet: invalid object header\n"); return -1; } if (parse_asn_length(buf, buf_size, i) < 0) return -1; return 0; } int parse_snmp_objheader6(u_char* buf, int buf_size, int* i) { if (*i >= buf_size) { logf("Unable to decode SNMP packet: buffer overflow\n"); return -1; } if (buf[(*i)++] != 0x06) { logf("Unable to decode SNMP packet: invalid object header\n"); return -1; } if (skip_asn_length(buf, buf_size, i) < 0) return -1; return 0; } int parse_snmp_value(u_char* buf, int buf_size, int* i) { if (*i >= buf_size) { logf("Unable to decode SNMP packet: buffer overflow\n"); return -1; } if (buf[(*i)++] != 0x04) { logf("Unable to decode SNMP packet: invalid value\n"); return -1; } if (print_asn_string(buf, buf_size, i) < 0) return -1; return 0; } void parse_snmp_response(u_char* buf, int buf_size) { int i; i = 0; if (parse_snmp_header(buf, buf_size, &i) == -1) return; if (parse_snmp_version(buf, buf_size, &i) == -1) return; if (parse_snmp_community(buf, buf_size, &i) == -1) return; if (parse_snmp_pdu(buf, buf_size, &i) == -1) return; if (parse_snmp_requestid(buf, buf_size, &i) == -1) return; if (parse_snmp_errorcode(buf, buf_size, &i) == -1) return; if (parse_snmp_errorindex(buf, buf_size, &i) == -1) return; if (i+3 <= buf_size && buf[i] == 0x00 && buf[i+1] == 0x30 && buf[i+2] == 0x20) // Bug in an HP JetDirect i += 3; if (parse_snmp_objheader(buf, buf_size, &i) == -1) return; if (parse_snmp_objheader(buf, buf_size, &i) == -1) return; // yes, this should be called twice if (parse_snmp_objheader6(buf, buf_size, &i) == -1) return; if (parse_snmp_value(buf, buf_size, &i) == -1) return; logf("\n"); } /* Subtract the `struct timeval' values X and Y, * storing the result in RESULT. * Return 1 if the difference is negative, otherwise 0. */ inline int timeval_subtract (struct timeval *result, struct timeval *x, struct timeval *y) { int nsec; /* Perform the carry for the later subtraction by updating y. */ if (x->tv_usec < y->tv_usec) { nsec = (y->tv_usec - x->tv_usec) / 1000000 + 1; y->tv_usec -= 1000000 * nsec; y->tv_sec += nsec; } if (x->tv_usec - y->tv_usec > 1000000) { nsec = (x->tv_usec - y->tv_usec) / 1000000; y->tv_usec += 1000000 * nsec; y->tv_sec -= nsec; } /* Compute the time remaining to wait. tv_usec is certainly positive. */ result->tv_sec = x->tv_sec - y->tv_sec; result->tv_usec = x->tv_usec - y->tv_usec; /* Return 1 if result is negative. */ return x->tv_sec < y->tv_sec; } void receive_snmp(int sock, long wait, struct sockaddr_in* remote_addr) { struct timeval tv_now, tv_until, tv_wait; int remote_addr_len; char buf[1500]; int ret; fd_set fds; gettimeofday(&tv_now, NULL); tv_until.tv_sec = tv_now.tv_sec; tv_until.tv_usec = tv_now.tv_usec + wait * 1000; if (tv_until.tv_usec >= 1000000) { tv_until.tv_sec += tv_until.tv_usec / 1000000; tv_until.tv_usec = tv_until.tv_usec % 1000000; } tv_wait.tv_sec = wait / 1000; tv_wait.tv_usec = wait % 1000 * 1000; do { /* Put the socket into the fd set */ FD_ZERO(&fds); FD_SET(sock, &fds); if ((ret = select(sock+1, &fds, NULL, NULL, &tv_wait)) == -1) { printf("Error in pselect\n"); exit(1); } else if (ret > 0) { memset(&buf, 0x0, sizeof(buf)); remote_addr_len = sizeof(*remote_addr); ret = recvfrom(sock, &buf, sizeof(buf), 0, (struct sockaddr*)remote_addr, &remote_addr_len); if (ret < 0) { printf("Error in recvfrom\n"); } logf("%s ", inet_ntoa(remote_addr->sin_addr)); parse_snmp_response((u_char*)&buf, ret); if (o.log) fflush(o.log_fd); } gettimeofday(&tv_now, NULL); } while (timeval_subtract(&tv_wait, &tv_until, &tv_now) == 0); } int main(int argc, char* argv[]) { struct sockaddr_in local_addr; struct sockaddr_in remote_addr; int sock; int ret; int c, i; char sendbuf[1500]; int sendbuf_size; init_options(argc, argv); /* socket creation */ sock = socket(AF_INET, SOCK_DGRAM, 0); if (sock < 0) { printf("Error creating socket\n"); exit(1); } local_addr.sin_family = AF_INET; local_addr.sin_addr.s_addr = htonl(INADDR_ANY); local_addr.sin_port = htons(0); ret = bind(sock, (struct sockaddr *)&local_addr, sizeof(local_addr)); if (ret < 0) { printf("Error binding socket\n"); exit(1); } /* remote address */ remote_addr.sin_family = AF_INET; remote_addr.sin_port = htons(161); printf("Scanning %d hosts, %d communities\n", host_count, community_count); for (c=0; c < community_count; c++) { if (o.debug > 0) printf("Trying community %s\n", community[c]); sendbuf_size = build_snmp_req((char*)&sendbuf, sizeof(sendbuf), community[c]); for (i=0; i < host_count; i++) { remote_addr.sin_addr.s_addr = host[i].addr; if (o.debug > 1) printf("Sending to ip %s\n", inet_ntoa(*(struct in_addr*)&remote_addr.sin_addr.s_addr)); ret = sendto(sock, &sendbuf, sendbuf_size, 0, (struct sockaddr*)&remote_addr, sizeof(remote_addr)); if (ret < 0) { printf("Error in sendto: %s\n", strerror(errno)); /* exit(1); */ } receive_snmp(sock, o.wait, &remote_addr); } } if (o.debug > 0) printf("All packets sent, waiting for responses.\n"); /* wait for 5 seconds */ receive_snmp(sock, 5000, &remote_addr); if (o.debug > 0) printf("done.\n"); if (o.log) fclose(o.log_fd); return 0; } onesixtyone-0.3.2/README0100644000175000017500000000554407775744073014725 0ustar slunchoslunchoonesixtyone 0.3.2 By Solar Eclipse Download this software at http://www.phreedom.org/solar/onesixtyone/ The SNMP protocol is a stateless, datagram oriented protocol. An SNMP scanner is a program that sends SNMP requests to multiple IP addresses, trying different community strings and waiting for a reply. Unfortunately SNMP servers don't respond to requests with invalid community strings and the underlying UDP protocol does not reliably report closed UDP ports. This means that 'no response' from the probed IP address can mean either of the following: a) machine unreachable b) SNMP server not running c) invalid community string d) the response datagram has not yet arrived The approach taken by most SNMP scanners is to send the request, wait for n seconds and assume that the community string is invalid. If only 1 of every hundred scanned IP addresses responds to the SNMP request, the scanner will spend 99*n seconds waiting for replies that will never come. This makes traditional SNMP scanners very inefficient. onesixtyone takes a different approach to SNMP scanning. It takes advantage of the fact that SNMP is a connectionless protocol and sends all SNMP requests as fast as it can. Then the scanner waits for responses to come back and logs them, in a fashion similar to Nmap ping sweeps. By default onesixtyone waits for 10 milliseconds between sending packets, which is adequate for 100MBs switched networks. The user can adjust this value via the -w command line option. If set to 0, the scanner will send packets as fast as the kernel would accept them, which may lead to packet drop. Running onesixtyone on a class B network (switched 100MBs with 1Gbs backbone) with -w 10 gives us a performance of 3 seconds per class C, with no dropped packets. All 65536 IP addresses were scanned in less than 13 minutes. onesixtyone sends a request for the system.sysDescr.0 value, which is present on almost all SNMP enabled devices. This returned value gives us a description of the system software running on the device. Here is an excert of a log file: 192.168.120.92 [1234] HP ETHERNET MULTI-ENVIRONMENT,ROM A.05.03,JETDIRECT, JD24,EEPROM A.05.05 130.160.108.146 [public] Hardware: x86 Family 15 Model 0 Stepping 10 AT/AT COMPATIBLE - Software: Windows 2000 Version 5.0 (Build 2195 Uniprocessor Free) 192.168.112.64 [public] Power Macintosh, hardware type 406; MacOS 9.0; OpenTransport 2.5.2 192.168.104.254 [public] Novell NetWare 4.11 August 22, 1996 192.168.112.83 [public] Macintosh Quadra 650, System Software 7.1 192.168.244.210 [public] RICOH Aficio 850 / RICOH Network Printer D model 192.168.240.39 [public] Cisco Systems WS-C5000 192.168.244.103 [public] HPJ3210A AdvanceStack 10BT Switching Hub Management Module, ROM A.01.02, EEPROM A.01.01, HW A.01.00 I hope that this program is useful and I would appreciate any comments, suggestions or complaints. onesixtyone-0.3.2/dict.txt0100644000175000017500000000050607440040762015501 0ustar slunchosluncho1234 2read 4changes CISCO IBM OrigEquipMfr SNMP SUN access admin agent all cisco community default enable field guest hello ibm manager mngt monitor netman network none openview pass password private proxy public read read-only read-write root router secret security snmp snmpd solaris sun switch system tech test world write onesixtyone-0.3.2/ChangeLog0100644000175000017500000000063507776161261015604 0ustar slunchosluncho2004-01-05 onesixtyone 0.3.2 * fixed version number and added a Makefile 2002-03-17 onesixtyone 0.3.1 * replaced in_addr_t with int, should fix compile problems on some Linux distributions (thanks to skeruno) 2002-03-14 onesixtyone 0.3 * compiles on FreeBSD (thanks to Eric Zerangue) * compiles on OpenBSD (thanks to methodic) * compiles on Solaris 2002-03-01 onesixtyone 0.2 * initial public release onesixtyone-0.3.2/INSTALL0100644000175000017500000000036507776161233015062 0ustar slunchoslunchoLinux, FreeBSD, OpenBSD: gcc -o onesixtyone onesixtyone.c Solaris: gcc -o onesixtyone onesixtyone.c -lsocket -lnsl Installation is not necessary, just run the program from the current directory. If you wish you may copy it to /usr/local/bin onesixtyone-0.3.2/Makefile0100644000175000017500000000027007776160742015470 0ustar slunchoslunchoonesixtyone: onesixtyone.c gcc -o onesixtyone onesixtyone.c solaris: onesixtyone.c cc -o onesixtyone onesixtyone.c -lsocket -lnsl clean: rm -rf onesixtyone .PHONY: solaris clean