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