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