[insert project logo here (125x200px max)]

Navigator

Mailinglists

Please report any errors or ommissions you find to our `Help' mailinglist, or post a message in the Forums.

Copyright and Licensing Information

Snap is (c) Jonathan T. Moore, 1999-2002 and licensed under the GNU General Public License (GPL).

All other parts of Splash are (c) Willem de Bruijn, 2002-2003 and licensed under the BSD Open Source License.

All sourcecode is made publicly available.

Acknowledgement

Splash and the Splash website are hosted by SourceForge.net

SourceForge.net Logo

osi-open source certified logo

Splash - Documentation

SNMP Plus a Lightweight API for SNAP Handling

Main Page   Alphabetical List   Data Structures   File List   Data Fields   Globals  

snap-1.1-wjdb/utils/kinject.c

Go to the documentation of this file.
00001 /* $Id: kinject.c,v 1.1 2002/12/22 16:20:16 wdebruij Exp $ */
00002 
00003 #include <arpa/inet.h>
00004 #include <assert.h>
00005 #include <fcntl.h>
00006 #include <linux/ip.h>
00007 #include <netdb.h>
00008 #include <netinet/in.h>
00009 #include <unistd.h>
00010 #include <stdio.h>
00011 #include <string.h>
00012 #include <sys/socket.h>
00013 #include <sys/stat.h>
00014 #include <sys/types.h>
00015 #include "../lib/snap.h"
00016 #include "../lib/bytecode.h"
00017 #include "../lib/packet.h"
00018 #include "../lib/d_printf.h"
00019 #include "../lib/memalloc.h"
00020 #include "../lib/io.h"
00021 
00022 #define NIPQUAD(addr) \
00023         ((unsigned char *)&addr)[0], \
00024         ((unsigned char *)&addr)[1], \
00025         ((unsigned char *)&addr)[2], \
00026         ((unsigned char *)&addr)[3]
00027 
00028 #define IPPROTO_SNAP 130
00029 
00030 /* settable options */
00031 unsigned char out_ttl = 16;
00032 short int udpport = 7777;
00033 struct sockaddr_in destaddr;
00034 #ifdef USER_SPACE
00035 struct sockaddr_in srcaddr;
00036 #endif
00037 
00038 extern char *basename(const char *);
00039 void parse_cmdline(int argc,char **argv);
00040 
00041 int infd;
00042 
00043 int main(int argc,char **argv) {
00044   buffer_t inbuf;
00045   int sd;
00046   int packet_lenb;
00047   struct snaphdr *hdr;
00048   char ra_space[4];
00049 
00050   parse_cmdline(argc,argv);
00051 
00052   /* first suck in the binary packet */
00053   packet_lenb = file_to_str(infd,&inbuf);
00054   if (packet_lenb < inbuf.lenb)
00055     inbuf.lenb = packet_lenb;
00056   printf("read in %d bytes\n",inbuf.lenb);
00057 
00058   /* touch up certain SNAP header entries */
00059   hdr = (struct snaphdr *)inbuf.s;
00060 #ifdef USER_SPACE
00061   hdr->saddr = srcaddr.sin_addr.s_addr;
00062   hdr->daddr = destaddr.sin_addr.s_addr;
00063 #endif
00064   hdr->version = 1;
00065   hdr->flags = 0;
00066   hdr->sport = htons(udpport);
00067   
00068   /* open up raw socket */
00069   if ((sd = socket(AF_INET, SOCK_RAW, IPPROTO_SNAP)) < 0) {
00070     perror("inject: socket");
00071     exit(1);
00072   }
00073   
00074   /* set socket options : first, router alert */
00075   bzero(ra_space,4);
00076   ra_space[IPOPT_OPTVAL] = IPOPT_RA;
00077   ra_space[IPOPT_OLEN] = 4;
00078   if (setsockopt(sd, IPPROTO_IP, IP_OPTIONS, ra_space,
00079          sizeof(ra_space)) < 0) {
00080     perror("inject: setsockopt: router alert");
00081     exit(1);
00082   }
00083 
00084   /* now set resource bound as requested */
00085   if (setsockopt(sd, IPPROTO_IP, IP_TTL, 
00086          (char *)&out_ttl, sizeof(out_ttl)) < 0) {
00087     perror("inject: setsockopt: ttl");
00088     exit(1);
00089   }
00090 
00091   printf("sending to %d.%d.%d.%d\n",NIPQUAD(destaddr.sin_addr.s_addr));
00092 
00093   if (sendto(sd, inbuf.s, inbuf.lenb, 0, (struct sockaddr *)&destaddr,
00094          sizeof(destaddr)) < 0) {
00095     perror("sendto");
00096   }
00097 
00098   return(0);
00099 }
00100 
00101 void usage(int argc, char **argv) {
00102 #ifdef USER_SPACE
00103   printf("usage: %s [-?] [-t ttl] [-p udpport] src dest infile\n",basename(argv[0]));
00104   printf("\t-t : set the outgoing TTL (resource bound) (default=16)\n");
00105   printf("\t-p : set the source port number (default=7777)\n");
00106   printf("\t-? : print this help\n");
00107 #else
00108   printf("usage: %s [-?] [-t ttl] [-p udpport] dest infile\n",basename(argv[0]));
00109   printf("\t-t : set the outgoing TTL (resource bound) (default=16)\n");
00110   printf("\t-p : set the source port number (default=7777)\n");
00111   printf("\t-? : print this help\n");
00112 #endif
00113 }
00114 
00115 void parse_cmdline(int argc, char **argv) {
00116   char *opts = "?t:p:";
00117   char c;
00118   int args_expected = 3;
00119   int args_processed = 0;
00120   int argidx;
00121   char *infilename;
00122 
00123   while((c = getopt(argc,argv,opts)) != EOF) {
00124     switch(c) {
00125     case '?':
00126       usage(argc,argv);
00127       exit(1);
00128     case 't':
00129       out_ttl = atoi(optarg);
00130       if (out_ttl <= 0) {
00131     fprintf(stderr,"%s: invalid TTL: %d\n",basename(argv[0]),out_ttl);
00132     fflush(stderr);
00133     usage(argc,argv);
00134     exit(1);
00135       }
00136       fprintf(stderr,"%s: setting TTL to %d\n",basename(argv[0]),out_ttl);
00137       break;
00138     case 'p':
00139       udpport = atoi(optarg);
00140       if (udpport <= 0) {
00141     fprintf(stderr,"%s: invalid source port: %d\n",
00142         basename(argv[0]),udpport);
00143     fflush(stderr);
00144     usage(argc,argv);
00145     exit(1);
00146       }
00147       break;
00148     default:
00149       fprintf(stderr,"%s: unrecognized option -%c\n",
00150           basename(argv[0]),c);
00151       fflush(stderr);
00152       usage(argc,argv);
00153       exit(1);
00154     }
00155   }
00156   argidx = optind;
00157 
00158   bzero(&destaddr,sizeof(destaddr));
00159 
00160   while(args_processed < args_expected) {
00161     if (argidx >= argc) {
00162       /* missing arguments */
00163       printf("%s: missing argument(s)\n",basename(argv[0]));
00164       usage(argc,argv);
00165       exit(1);
00166     }
00167     switch(args_processed) {
00168     case 0: {           /* source address */
00169       struct hostent *srchostp = gethostbyname(argv[argidx]);
00170       if (srchostp == NULL) {
00171     fprintf(stderr,"%s: unknown dest host %s\n",
00172         basename(argv[0]),argv[argidx]);
00173     fflush(stderr);
00174     usage(argc,argv);
00175     exit(1);
00176       }
00177       assert(srchostp->h_addrtype == AF_INET);
00178       assert(srchostp->h_length == sizeof(unsigned int));
00179       memcpy(&srcaddr.sin_addr.s_addr,srchostp->h_addr,srchostp->h_length);
00180       srcaddr.sin_family = AF_INET;
00181       break;
00182     }
00183     case 1: {           /* destination address */
00184       struct hostent *desthostp = gethostbyname(argv[argidx]);
00185       if (desthostp == NULL) {
00186     fprintf(stderr,"%s: unknown dest host %s\n",
00187         basename(argv[0]),argv[argidx]);
00188     fflush(stderr);
00189     usage(argc,argv);
00190     exit(1);
00191       }
00192       assert(desthostp->h_addrtype == AF_INET);
00193       assert(desthostp->h_length == sizeof(unsigned int));
00194       memcpy(&destaddr.sin_addr.s_addr,desthostp->h_addr,desthostp->h_length);
00195       destaddr.sin_family = AF_INET;
00196       break;
00197     }
00198     case 2:         /* packet file name */
00199       infilename = argv[argidx];
00200       if (strcmp(infilename,"-") == 0) {
00201     infd = 0;       /* stdin */
00202       } else {
00203     infd = open(infilename,O_RDONLY);
00204     if (infd == -1) {
00205       fprintf(stderr,"%s: unable to open file \"%s\" for input\n",
00206           basename(argv[0]),infilename);
00207       fflush(stderr);
00208       exit(1);
00209     }
00210       }
00211       break;
00212     }
00213     argidx++;
00214     args_processed++;
00215   }
00216   if (argidx < argc) {
00217     /* extra arguments */
00218     printf("%s: extra argument(s)\n",basename(argv[0]));
00219     usage(argc,argv);
00220     exit(1);
00221   }
00222   return;
00223 }
00224