Return to sendtcp.c CVS log

Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / hping2

Annotation of embedaddon/hping2/sendtcp.c, revision 1.1.1.1

1.1       misho       1: /* 
                      2:  * $smu-mark$ 
                      3:  * $name: sendtcp.c$ 
                      4:  * $author: Salvatore Sanfilippo <antirez@invece.org>$ 
                      5:  * $copyright: Copyright (C) 1999 by Salvatore Sanfilippo$ 
                      6:  * $license: This software is under GPL version 2 of license$ 
                      7:  * $date: Fri Nov  5 11:55:49 MET 1999$ 
                      8:  * $rev: 8$ 
                      9:  */ 
                     10: 
                     11: #include <stdio.h>
                     12: #include <string.h>
                     13: #include <stdlib.h>
                     14: #include <time.h>
                     15: #include <sys/time.h>
                     16: #include <unistd.h>
                     17: #include <signal.h>
                     18: 
                     19: #include "hping2.h"
                     20: #include "globals.h"
                     21: 
                     22: void send_tcp(void)
                     23: {
                     24:        int                     packet_size;
                     25:        int                     tcp_opt_size = 0;
                     26:        char                    *packet, *data;
                     27:        struct mytcphdr         *tcp;
                     28:        struct pseudohdr        *pseudoheader;
                     29:        unsigned char           *tstamp;
                     30: 
                     31:        if (opt_tcp_timestamp)
                     32:                tcp_opt_size = 12;
                     33: 
                     34:        packet_size = TCPHDR_SIZE + tcp_opt_size + data_size;
                     35:        packet = malloc(PSEUDOHDR_SIZE + packet_size);
                     36:        if (packet == NULL) {
                     37:                perror("[send_tcphdr] malloc()");
                     38:                return;
                     39:        }
                     40:        pseudoheader = (struct pseudohdr*) packet;
                     41:        tcp =  (struct mytcphdr*) (packet+PSEUDOHDR_SIZE);
                     42:        tstamp = (unsigned char*) (packet+PSEUDOHDR_SIZE+TCPHDR_SIZE);
                     43:        data = (char*) (packet+PSEUDOHDR_SIZE+TCPHDR_SIZE+tcp_opt_size);
                     44:        
                     45:        memset(packet, 0, PSEUDOHDR_SIZE+packet_size);
                     46: 
                     47:        /* tcp pseudo header */
                     48:        memcpy(&pseudoheader->saddr, &local.sin_addr.s_addr, 4);
                     49:        memcpy(&pseudoheader->daddr, &remote.sin_addr.s_addr, 4);
                     50:        pseudoheader->protocol          = 6; /* tcp */
                     51:        pseudoheader->lenght            = htons(TCPHDR_SIZE+tcp_opt_size+data_size);
                     52: 
                     53:        /* tcp header */
                     54:        tcp->th_dport   = htons(dst_port);
                     55:        tcp->th_sport   = htons(src_port);
                     56: 
                     57:        /* sequence number and ack are random if not set */
                     58:        tcp->th_seq = (set_seqnum) ? htonl(tcp_seqnum) : htonl(rand());
                     59:        tcp->th_ack = (set_ack) ? htonl(tcp_ack) : htonl(rand());
                     60: 
                     61:        tcp->th_off     = src_thoff + (tcp_opt_size >> 2);
                     62:        tcp->th_win     = htons(src_winsize);
                     63:        tcp->th_flags   = tcp_th_flags;
                     64: 
                     65:        /* tcp timestamp option */
                     66:        if (opt_tcp_timestamp) {
                     67:                __u32 randts = rand() ^ (rand() << 16);
                     68:                tstamp[0] = tstamp[1] = 1; /* NOOP */
                     69:                tstamp[2] = 8;
                     70:                tstamp[3] = 10; /* 10 bytes, kind+len+T1+T2 */
                     71:                memcpy(tstamp+4, &randts, 4); /* random */
                     72:                memset(tstamp+8, 0, 4); /* zero */
                     73:        }
                     74: 
                     75:        /* data */
                     76:        data_handler(data, data_size);
                     77: 
                     78:        /* compute checksum */
                     79: #ifdef STUPID_SOLARIS_CHECKSUM_BUG
                     80:        tcp->th_sum = packet_size;
                     81: #else
                     82:        tcp->th_sum = cksum((u_short*) packet, PSEUDOHDR_SIZE +
                     83:                      packet_size);
                     84: #endif
                     85: 
                     86:        /* adds this pkt in delaytable */
                     87:        delaytable_add(sequence, src_port, time(NULL), get_usec(), S_SENT);
                     88: 
                     89:        /* send packet */
                     90:        send_ip_handler(packet+PSEUDOHDR_SIZE, packet_size);
                     91:        free(packet);
                     92: 
                     93:        sequence++;     /* next sequence number */
                     94:        if (!opt_keepstill)
                     95:                src_port = (sequence + initsport) % 65536;
                     96: 
                     97:        if (opt_force_incdport)
                     98:                dst_port++;
                     99: }