util.c

   1 /* util.c
   2  * Utility routines
   3  *
   4  * $Id$
   5  *
   6  * Wireshark - Network traffic analyzer
   7  * By Gerald Combs <gerald@wireshark.org>
   8  * Copyright 1998 Gerald Combs
   9  *
  10  * This program is free software; you can redistribute it and/or
  11  * modify it under the terms of the GNU General Public License
  12  * as published by the Free Software Foundation; either version 2
  13  * of the License, or (at your option) any later version.
  14  *
  15  * This program is distributed in the hope that it will be useful,
  16  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  17  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  18  * GNU General Public License for more details.
  19  *
  20  * You should have received a copy of the GNU General Public License
  21  * along with this program; if not, write to the Free Software
  22  * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
  23  */
  24
  25 #ifdef HAVE_CONFIG_H
  26 # include "config.h"
  27 #endif
  28
  29 #include <glib.h>
  30
  31 #include <stdlib.h>
  32 #include <string.h>
  33 #include <stdio.h>
  34 #include <errno.h>
  35
  36 #ifdef HAVE_UNISTD_H
  37 #include <unistd.h>
  38 #endif
  39
  40 #include <epan/address.h>
  41 #include <epan/addr_resolv.h>
  42
  43 #include "util.h"
  44
  45 /*
  46  * Collect command-line arguments as a string consisting of the arguments,
  47  * separated by spaces.
  48  */
  49 char *
  50 get_args_as_string(int argc, char **argv, int optind)
  51 {
  52         int len;
  53         int i;
  54         char *argstring;
  55
  56         /*
  57          * Find out how long the string will be.
  58          */
  59         len = 0;
  60         for (i = optind; i < argc; i++) {
  61                 len += strlen(argv[i]);
  62                 len++;  /* space, or '\0' if this is the last argument */
  63         }
  64
  65         /*
  66          * Allocate the buffer for the string.
  67          */
  68         argstring = g_malloc(len);
  69
  70         /*
  71          * Now construct the string.
  72          */
  73         strcpy(argstring, "");
  74         i = optind;
  75         for (;;) {
  76                 strcat(argstring, argv[i]);
  77                 i++;
  78                 if (i == argc)
  79                         break;
  80                 strcat(argstring, " ");
  81         }
  82         return argstring;
  83 }
  84
  85 /* Compute the difference between two seconds/microseconds time stamps. */
  86 void
  87 compute_timestamp_diff(gint *diffsec, gint *diffusec,
  88         guint32 sec1, guint32 usec1, guint32 sec2, guint32 usec2)
  89 {
  90   if (sec1 == sec2) {
  91     /* The seconds part of the first time is the same as the seconds
  92        part of the second time, so if the microseconds part of the first
  93        time is less than the microseconds part of the second time, the
  94        first time is before the second time.  The microseconds part of
  95        the delta should just be the difference between the microseconds
  96        part of the first time and the microseconds part of the second
  97        time; don't adjust the seconds part of the delta, as it's OK if
  98        the microseconds part is negative. */
  99
 100     *diffsec = sec1 - sec2;
 101     *diffusec = usec1 - usec2;
 102   } else if (sec1 <= sec2) {
 103     /* The seconds part of the first time is less than the seconds part
 104        of the second time, so the first time is before the second time.
 105
 106        Both the "seconds" and "microseconds" value of the delta
 107        should have the same sign, so if the difference between the
 108        microseconds values would be *positive*, subtract 1,000,000
 109        from it, and add one to the seconds value. */
 110     *diffsec = sec1 - sec2;
 111     if (usec2 >= usec1) {
 112       *diffusec = usec1 - usec2;
 113     } else {
 114       *diffusec = (usec1 - 1000000) - usec2;
 115       (*diffsec)++;
 116     }
 117   } else {
 118     /* Oh, good, we're not caught in a chronosynclastic infindibulum. */
 119     *diffsec = sec1 - sec2;
 120     if (usec2 <= usec1) {
 121       *diffusec = usec1 - usec2;
 122     } else {
 123       *diffusec = (usec1 + 1000000) - usec2;
 124       (*diffsec)--;
 125     }
 126   }
 127 }
 128
 129 /* Try to figure out if we're remotely connected, e.g. via ssh or
 130    Terminal Server, and create a capture filter that matches aspects of the
 131    connection.  We match the following environment variables:
 132
 133    SSH_CONNECTION (ssh): <remote IP> <remote port> <local IP> <local port>
 134    SSH_CLIENT (ssh): <remote IP> <remote port> <local port>
 135    REMOTEHOST (tcsh, others?): <remote name>
 136    DISPLAY (x11): [remote name]:<display num>
 137    SESSIONNAME (terminal server): <remote name>
 138  */
 139
 140 const gchar *get_conn_cfilter(void) {
 141         static GString *filter_str = NULL;
 142         gchar *env, **tokens;
 143
 144         if (filter_str == NULL) {
 145                 filter_str = g_string_new("");
 146         }
 147         if ((env = getenv("SSH_CONNECTION")) != NULL) {
 148                 tokens = g_strsplit(env, " ", 4);
 149                 if (tokens[3]) {
 150                         g_string_sprintf(filter_str, "not (tcp port %s and %s host %s "
 151                                                          "and tcp port %s and %s host %s)", tokens[1], host_ip_af(tokens[0]), tokens[0],
 152                                 tokens[3], host_ip_af(tokens[2]), tokens[2]);
 153                         return filter_str->str;
 154                 }
 155         } else if ((env = getenv("SSH_CLIENT")) != NULL) {
 156                 tokens = g_strsplit(env, " ", 3);
 157                 g_string_sprintf(filter_str, "not (tcp port %s and %s host %s "
 158                         "and tcp port %s)", tokens[1], host_ip_af(tokens[0]), tokens[0], tokens[2]);
 159                 return filter_str->str;
 160         } else if ((env = getenv("REMOTEHOST")) != NULL) {
 161                 if (strcasecmp(env, "localhost") == 0 || strcmp(env, "127.0.0.1") == 0) {
 162                         return "";
 163                 }
 164                 g_string_sprintf(filter_str, "not %s host %s", host_ip_af(env), env);
 165                 return filter_str->str;
 166         } else if ((env = getenv("DISPLAY")) != NULL) {
 167                 tokens = g_strsplit(env, ":", 2);
 168                 if (tokens[0] && tokens[0][0] != 0) {
 169                         if (strcasecmp(tokens[0], "localhost") == 0 ||
 170                                         strcmp(tokens[0], "127.0.0.1") == 0) {
 171                                 return "";
 172                         }
 173                         g_string_sprintf(filter_str, "not %s host %s",
 174                                 host_ip_af(tokens[0]), tokens[0]);
 175                         return filter_str->str;
 176                 }
 177         } else if ((env = getenv("SESSIONNAME")) != NULL) {
 178         /* Apparently the KB article at
 179          * http://technet2.microsoft.com/WindowsServer/en/library/6caf87bf-3d70-4801-9485-87e9ec3df0171033.mspx?mfr=true
 180          * is incorrect.  There are _plenty_ of cases where CLIENTNAME
 181          * and SESSIONNAME are set outside of a Terminal Terver session.
 182          * It looks like Terminal Server sets SESSIONNAME to RDP-TCP#<number>
 183          * for "real" sessions.
 184          *
 185          * XXX - There's a better way to do this described at
 186          * http://www.microsoft.com/technet/archive/termsrv/maintain/featusability/tsrvapi.mspx?mfr=true
 187          */
 188                 if (g_strncasecmp(env, "rdp", 3) == 0) {
 189                         g_string_sprintf(filter_str, "not tcp port 3389");
 190                         return filter_str->str;
 191                 }
 192         }
 193         return "";
 194 }