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 #include <epan/ws_strsplit.h>
  43
  44 #include "util.h"
  45
  46 /*
  47  * Collect command-line arguments as a string consisting of the arguments,
  48  * separated by spaces.
  49  */
  50 char *
  51 get_args_as_string(int argc, char **argv, int optind)
  52 {
  53         int len;
  54         int i;
  55         char *argstring;
  56
  57         /*
  58          * Find out how long the string will be.
  59          */
  60         len = 0;
  61         for (i = optind; i < argc; i++) {
  62                 len += strlen(argv[i]);
  63                 len++;  /* space, or '\0' if this is the last argument */
  64         }
  65
  66         /*
  67          * Allocate the buffer for the string.
  68          */
  69         argstring = g_malloc(len);
  70
  71         /*
  72          * Now construct the string.
  73          */
  74         strcpy(argstring, "");
  75         i = optind;
  76         for (;;) {
  77                 strcat(argstring, argv[i]);
  78                 i++;
  79                 if (i == argc)
  80                         break;
  81                 strcat(argstring, " ");
  82         }
  83         return argstring;
  84 }
  85
  86 /* Compute the difference between two seconds/microseconds time stamps. */
  87 void
  88 compute_timestamp_diff(gint *diffsec, gint *diffusec,
  89         guint32 sec1, guint32 usec1, guint32 sec2, guint32 usec2)
  90 {
  91   if (sec1 == sec2) {
  92     /* The seconds part of the first time is the same as the seconds
  93        part of the second time, so if the microseconds part of the first
  94        time is less than the microseconds part of the second time, the
  95        first time is before the second time.  The microseconds part of
  96        the delta should just be the difference between the microseconds
  97        part of the first time and the microseconds part of the second
  98        time; don't adjust the seconds part of the delta, as it's OK if
  99        the microseconds part is negative. */
 100
 101     *diffsec = sec1 - sec2;
 102     *diffusec = usec1 - usec2;
 103   } else if (sec1 <= sec2) {
 104     /* The seconds part of the first time is less than the seconds part
 105        of the second time, so the first time is before the second time.
 106
 107        Both the "seconds" and "microseconds" value of the delta
 108        should have the same sign, so if the difference between the
 109        microseconds values would be *positive*, subtract 1,000,000
 110        from it, and add one to the seconds value. */
 111     *diffsec = sec1 - sec2;
 112     if (usec2 >= usec1) {
 113       *diffusec = usec1 - usec2;
 114     } else {
 115       *diffusec = (usec1 - 1000000) - usec2;
 116       (*diffsec)++;
 117     }
 118   } else {
 119     /* Oh, good, we're not caught in a chronosynclastic infindibulum. */
 120     *diffsec = sec1 - sec2;
 121     if (usec2 <= usec1) {
 122       *diffusec = usec1 - usec2;
 123     } else {
 124       *diffusec = (usec1 + 1000000) - usec2;
 125       (*diffsec)--;
 126     }
 127   }
 128 }
 129
 130 /* Try to figure out if we're remotely connected, e.g. via ssh or
 131    Terminal Server, and create a capture filter that matches aspects of the
 132    connection.  We match the following environment variables:
 133
 134    SSH_CONNECTION (ssh): <remote IP> <remote port> <local IP> <local port>
 135    SSH_CLIENT (ssh): <remote IP> <remote port> <local port>
 136    REMOTEHOST (tcsh, others?): <remote name>
 137    DISPLAY (x11): [remote name]:<display num>
 138    SESSIONNAME (terminal server): <remote name>
 139  */
 140
 141 const gchar *get_conn_cfilter(void) {
 142         static GString *filter_str = NULL;
 143         gchar *env, **tokens;
 144         char *lastp, *lastc, *p;
 145         char *pprotocol = NULL;
 146         char *phostname = NULL;
 147         size_t hostlen;
 148
 149         if (filter_str == NULL) {
 150                 filter_str = g_string_new("");
 151         }
 152         if ((env = getenv("SSH_CONNECTION")) != NULL) {
 153                 tokens = g_strsplit(env, " ", 4);
 154                 if (tokens[3]) {
 155                         g_string_sprintf(filter_str, "not (tcp port %s and %s host %s "
 156                                                          "and tcp port %s and %s host %s)", tokens[1], host_ip_af(tokens[0]), tokens[0],
 157                                 tokens[3], host_ip_af(tokens[2]), tokens[2]);
 158                         return filter_str->str;
 159                 }
 160         } else if ((env = getenv("SSH_CLIENT")) != NULL) {
 161                 tokens = g_strsplit(env, " ", 3);
 162                 g_string_sprintf(filter_str, "not (tcp port %s and %s host %s "
 163                         "and tcp port %s)", tokens[1], host_ip_af(tokens[0]), tokens[0], tokens[2]);
 164                 return filter_str->str;
 165         } else if ((env = getenv("REMOTEHOST")) != NULL) {
 166                 if (strcasecmp(env, "localhost") == 0 || strcmp(env, "127.0.0.1") == 0) {
 167                         return "";
 168                 }
 169                 g_string_sprintf(filter_str, "not %s host %s", host_ip_af(env), env);
 170                 return filter_str->str;
 171         } else if ((env = getenv("DISPLAY")) != NULL) {
 172                 /*
 173                  * This mirrors what _X11TransConnectDisplay() does.
 174                  * Note that, on some systems, the hostname can
 175                  * being with "/", which means that it's a pathname
 176                  * of a UNIX domain socket to connect to.
 177                  *
 178                  * The comments mirror those in _X11TransConnectDisplay(),
 179                  * too. :-)
 180                  *
 181                  * Display names may be of the following format:
 182                  *
 183                  *    [protoco./] [hostname] : [:] displaynumber [.screennumber]
 184                  *
 185                  * A string with exactly two colons separating hostname
 186                  * from the display indicates a DECnet style name.  Colons
 187                  * in the hostname may occur if an IPv6 numeric address
 188                  * is used as the hostname.  An IPv6 numeric address may
 189                  * also end in a double colon, so three colons in a row
 190                  * indicates an IPv6 address ending in :: followed by
 191                  * :display.  To make it easier for people to read, an
 192                  * IPv6 numeric address hostname may be surrounded by []
 193                  * in a similar fashion to the IPv6 numeric address URL
 194                  * syntax defined by IETF RFC 2732.
 195                  *
 196                  * If no hostname and no protocol is specified, the string
 197                  * is interpreted as the most efficient local connection
 198                  * to a server on the same machine.  This is usually:
 199                  *
 200                  *    o shared memory
 201                  *    o local stream
 202                  *    o UNIX domain socket
 203                  *    o TCP to local host.
 204                  */
 205
 206                 p = env;
 207
 208                 /*
 209                  * Step 0, find the protocol.  This is delimited by
 210                  * the optional slash ('/').
 211                  */
 212                 for (lastp = p; *p != '\0' && *p != ':' && *p != '/'; p++)
 213                         ;
 214                 if (*p == '\0')
 215                         return "";      /* must have a colon */
 216
 217                 if (p != lastp && *p != ':') {  /* protocol given? */
 218                         /* Yes */
 219                         pprotocol = p;
 220
 221                         /* Is it TCP? */
 222                         if (p - lastp != 3 || strncasecmp(lastp, "tcp", 3) != 0)
 223                                 return "";      /* not TCP */
 224                         p++;                    /* skip the '/' */
 225                 } else
 226                         p = env;                /* reset the pointer in
 227                                                    case no protocol was given */
 228
 229                 /*
 230                  * Step 1, find the hostname.  This is delimited either by
 231                  * one colon, or two colons in the case of DECnet (DECnet
 232                  * Phase V allows a single colon in the hostname).  (See
 233                  * note above regarding IPv6 numeric addresses with
 234                  * triple colons or [] brackets.)
 235                  */
 236                 lastp = p;
 237                 lastc = NULL;
 238                 for (; *p != '\0'; p++)
 239                         if (*p == ':')
 240                                 lastc = p;
 241
 242                 if (lastc == NULL)
 243                         return "";              /* must have a colon */
 244
 245                 if ((lastp != lastc) && (*(lastc - 1) == ':')
 246                     && (((lastc - 1) == lastp) || (*(lastc - 2) != ':'))) {
 247                         /* DECnet display specified */
 248                         return "";
 249                 } else
 250                         hostlen = lastc - lastp;
 251
 252                 if (hostlen == 0)
 253                         return "";      /* no hostname supplied */
 254
 255                 phostname = g_malloc(hostlen + 1);
 256                 memcpy(phostname, lastp, hostlen);
 257                 phostname[hostlen] = '\0';
 258
 259                 if (pprotocol == NULL) {
 260                         /*
 261                          * No protocol was explicitly specified, so it
 262                          * could be a local connection over a transport
 263                          * that we won't see.
 264                          *
 265                          * Does the host name refer to the local host?
 266                          * If so, the connection would probably be a
 267                          * local connection.
 268                          *
 269                          * XXX - compare against our host name?
 270                          * _X11TransConnectDisplay() does.
 271                          */
 272                         if (strcasecmp(phostname, "localhost") == 0 ||
 273                             strcmp(phostname, "127.0.0.1") == 0) {
 274                                 g_free(phostname);
 275                                 return "";
 276                         }
 277
 278                         /*
 279                          * A host name of "unix" (case-sensitive) also
 280                          * causes a local connection.
 281                          */
 282                         if (strcmp(phostname, "unix") == 0) {
 283                                 g_free(phostname);
 284                                 return "";
 285                         }
 286
 287                         /*
 288                          * Does the host name begin with "/"?  If so,
 289                          * it's presumed to be the pathname of a
 290                          * UNIX domain socket.
 291                          */
 292                         if (phostname[0] == '/') {
 293                                 g_free(phostname);
 294                                 return "";
 295                         }
 296                 }
 297
 298                 g_string_sprintf(filter_str, "not %s host %s",
 299                         host_ip_af(phostname), phostname);
 300                 g_free(phostname);
 301                 return filter_str->str;
 302         } else if ((env = getenv("SESSIONNAME")) != NULL) {
 303                 /* Apparently the KB article at
 304                  * http://technet2.microsoft.com/WindowsServer/en/library/6caf87bf-3d70-4801-9485-87e9ec3df0171033.mspx?mfr=true
 305                  * is incorrect.  There are _plenty_ of cases where CLIENTNAME
 306                  * and SESSIONNAME are set outside of a Terminal Terver session.
 307                  * It looks like Terminal Server sets SESSIONNAME to RDP-TCP#<number>
 308                  * for "real" sessions.
 309                  *
 310                  * XXX - There's a better way to do this described at
 311                  * http://www.microsoft.com/technet/archive/termsrv/maintain/featusability/tsrvapi.mspx?mfr=true
 312                  */
 313                 if (g_strncasecmp(env, "rdp", 3) == 0) {
 314                         g_string_sprintf(filter_str, "not tcp port 3389");
 315                         return filter_str->str;
 316                 }
 317         }
 318         return "";
 319 }