/* $Id: utils.c,v 1.11 2001/10/14 17:58:30 fygrave Exp $ */
/*
** Copyright (C) 2001 Fyodor Yarochkin <fygrave@tigerteam.net>,
**                    Ofir Arkin       <ofir@sys-security.com>
**
** 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.
**
** All material for nonprofit, educational use only.
**
** 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 "xprobe.h"

int resolve_target(char *host, struct sockaddr_in * sa) {

    struct hostent *host_serv;

    bzero(sa, sizeof(struct sockaddr_in));
    sa->sin_family = AF_INET;

    if ((sa->sin_addr.s_addr = inet_addr(host)) == INADDR_NONE)
    {
	host_serv = gethostbyname(host);
	if (host_serv == NULL)
	    return -1;
	bcopy(host_serv->h_addr, &(sa->sin_addr), host_serv->h_length);
    }
    return 0;
}

int parse_hostname(char *trghost, hstnet_t *targ) {
    struct sockaddr_in to;
    char *host;
    char *mask;

    host = strdup(trghost);
    if((mask=index(host,'/'))!=NULL) {
		*mask='\0';
		mask++;
        if ((targ->netmask = parsemask(mask)) == 0) {
            free(host);
            return -1;
        }
    } else {
        targ->netmask = 0xffffffff;
    }

    if (resolve_target(host, &to)<0) {
        herror("Can not resolve");
        free(host);
        return -1;
    }
    bcopy((void *)&to.sin_addr,
          (void *)&targ->addr, sizeof(struct in_addr));
    targ->addr &= targ->netmask; 
    free(host);
    return 0;
}

unsigned long parsemask(char *mask) {

    if (!mask) return 0;
    if (!atoi(mask) || atoi(mask) > 32) {
        fprintf(stderr,"Incorrect netmask specification: %s "
                "(1-32 allowed)\n", mask);
        return 0;
    }
    return htonl((0xffffffff<<(32-atoi(mask))));
}

/*
 * Checksum routine for Internet Protocol family headers (C Version)
 */
unsigned short
in_cksum(addr, len)
	unsigned short *addr;
	int len;
{
	register int nleft = len;
	register unsigned short *w = addr;
	register unsigned short answer;
	register int sum = 0;

	/*
	 *  Our algorithm is simple, using a 32 bit accumulator (sum),
	 *  we add sequential 16 bit words to it, and at the end, fold
	 *  back all the carry bits from the top 16 bits into the lower
	 *  16 bits.
	 */
	while (nleft > 1)  {
		sum += *w++;
		nleft -= 2;
	}

	/* mop up an odd byte, if necessary */
	if (nleft == 1)
		sum += *(u_char *)w;

	/*
	 * add back carry outs from top 16 bits to low 16 bits
	 */
	sum = (sum >> 16) + (sum & 0xffff);	/* add hi 16 to low 16 */
	sum += (sum >> 16);			/* add carry */
	answer = ~sum;				/* truncate to 16 bits */
	return (answer);
}

void tree_message(const char *format,...) {
    va_list ap;

    if (!verbose) return;
    va_start(ap, format);
    fprintf(logfn,"TREE: ");
    vfprintf(logfn, format, ap);
    fprintf(logfn,"\n");
    if (logfn != stderr) {    
        fprintf(stderr,"TREE: ");
        vfprintf(stderr, format, ap);
        fprintf(stderr,"\n");
    }
    va_end(ap);
}

void fin_message(const char *format,...) {
    va_list ap;

    va_start(ap, format);
    fprintf(logfn,"FINAL:[ ");
    vfprintf(logfn, format, ap);
    fprintf(logfn," ]\n");
    if (logfn != stderr) {
        fprintf(stderr,"FINAL:[ ");
        vfprintf(stderr, format, ap);
        fprintf(stderr," ]\n");
    }
    va_end(ap);
}

void log_message(const char *format,...) {
    va_list ap;

    va_start(ap, format);
    fprintf(logfn,"LOG: ");
    vfprintf(logfn, format, ap);
    fprintf(logfn,"\n");
    if (logfn != stderr) {
        fprintf(stderr,"LOG: ");
        vfprintf(stderr, format, ap);
        fprintf(stderr,"\n");
    }
    va_end(ap);
}

void hexdump(unsigned char *ptr, ssize_t len) {

    if (len<0 || !ptr) return;

    while(len--) 
        fprintf(logfn,"%02x%c", *ptr++ & 0xff,
        len % 16? ' ':'\n');

}

void free_res(rpack_t **rpack) {

    if (!*rpack) return;
    if ((*rpack)->orig_pkt) free((*rpack)->orig_pkt);
    if ((*rpack)->pkt)      free((*rpack)->pkt);
    free(*rpack);
    *rpack = NULL;

}

struct in_addr get_iface_addr(char *iname) {
    struct ifreq ifr;
    int sd;
    struct in_addr retval;
    struct sockaddr_in *sin;

    if((sd = socket(AF_INET, SOCK_DGRAM, 0)) < 0) {
        perror("socket");
        exit(1);
    }

    strncpy(ifr.ifr_name, iname, sizeof(ifr.ifr_name));

    if (ioctl(sd, SIOCGIFADDR,(char *)&ifr) < 0) {
        perror("ioctl(SIOCGIFADDR)");
        close(sd);
        exit(1); /* interface doesn't exist or your kernel is flacky */
    }
    close(sd);
    sin = (struct sockaddr_in *) &ifr.ifr_addr;
    memcpy((void *)&retval, (void *)&(sin->sin_addr.s_addr), sizeof(retval));
    return retval;
 
}

/* udp packet checksum calculation.. length _SHOULD_ include udpheader
 * lenghth
 */
unsigned short udp_cksum_calc(struct ip *ip, struct udphdr *udp, unsigned short length) {
     ipovly_t  *ipov;
     unsigned char *buf;
     struct udphdr *ludp;
     unsigned short cksum;

     if((buf=calloc(sizeof(ipovly_t) + length, 1))== NULL) {
         perror("calloc");
         return -1;
     }
     memcpy((void *)(buf + sizeof(ipovly_t)), (void *)udp, length);
     ipov = (ipovly_t *)buf;
     ludp = (struct udphdr *)(ipov + 1);
     ipov->ih_src = ip->ip_src;
     ipov->ih_dst = ip->ip_dst;
     ipov->ih_pr  = ip->ip_p;
     ipov->ih_len = htons(length);
     ludp->uh_sum = 0;
     cksum = in_cksum((unsigned short *)buf, length);
     if (!cksum)
         cksum = 0xffff;
     return cksum;
}

void make_ippkt(struct ip *ip,
                unsigned char proto, 
                struct in_addr srcaddr,
                struct in_addr dstaddr,
                unsigned short pktlen,
                unsigned short ip_off,
                unsigned short ip_tos) {


    ip->ip_p     = proto;
    ip->ip_src   = srcaddr;
    ip->ip_dst   = dstaddr;
#if defined(__OpenBSD__)    
    ip->ip_len   = htons(pktlen);
#else    
    ip->ip_len   = pktlen;
#endif    
    ip->ip_ttl   = 250;
    ip->ip_v     = IP_VERSION;
    ip->ip_hl    = sizeof(struct ip) >> 2;
#if defined(__linux__) || defined(__OpenBSD__)    
    ip->ip_off   = htons((unsigned short) ip_off);
#else
    ip->ip_off   = (unsigned short) ip_off;
#endif    
    ip->ip_tos  = ip_tos; 
    ip->ip_id   = rand();

}