* various HIGs suggest that you should, for example, suggest that the
* user remove files if the file system is full. Perhaps that's because
* they're providing guidelines for people less sophisticated than the
- * typical Ethereal user is, but....
+ * typical Wireshark user is, but....
*/
void
open_failure_alert_box(const char *filename, int err, gboolean for_writing)
* various HIGs suggest that you should, for example, suggest that the
* user remove files if the file system is full. Perhaps that's because
* they're providing guidelines for people less sophisticated than the
- * typical Ethereal user is, but....
+ * typical Wireshark user is, but....
*/
void
write_failure_alert_box(const char *filename, int err)
#endif
"\n", VERSION);
fprintf(output, "Prints information about capture files.\n");
- fprintf(output, "See http://www.ethereal.com for more information.\n");
+ fprintf(output, "See http://www.wireshark.org for more information.\n");
fprintf(output, "\n");
fprintf(output, "Usage: capinfos [options] <infile> ...\n");
fprintf(output, "\n");
* value, rather than as a DLT_ value, we will assume this is AIX's
* non-standard, incompatible libpcap, rather than a standard libpcap,
* and will map the link-layer type to the standard DLT_ value for
- * that link-layer type, as that's what the rest of Ethereal expects.
+ * that link-layer type, as that's what the rest of Wireshark expects.
*
* (This means the capture files won't be readable by a tcpdump
* linked with AIX's non-standard libpcap, but so it goes. They
- * *will* be readable by standard versions of tcpdump, Ethereal,
+ * *will* be readable by standard versions of tcpdump, Wireshark,
* and so on.)
*
* XXX - if we conclude we're using AIX libpcap, should we also
/*
* That's the RFC 1573 value for 802.3; map it to
* DLT_EN10MB.
- * (libpcap, tcpdump, Ethereal, etc. don't care if
+ * (libpcap, tcpdump, Wireshark, etc. don't care if
* it's Ethernet or 802.3.)
*/
linktype = 1;
/* capture-wpcap.c
* WinPcap-specific interfaces for capturing. We load WinPcap at run
- * time, so that we only need one Ethereal binary and one Tethereal binary
+ * time, so that we only need one Wireshark binary and one Twireshark binary
* for Windows, regardless of whether WinPcap is installed or not.
*
* $Id$
"\n"
"Help about capturing can be found at:\n"
"\n"
-" http://wiki.ethereal.com/CaptureSetup"
+" http://wiki.wireshark.org/CaptureSetup"
#ifdef _WIN32
"\n\n"
"Wireless (Wi-Fi/WLAN):\n"
"\n"
"Help about capturing can be found at:\n"
"\n"
-" http://wiki.ethereal.com/CaptureSetup"
+" http://wiki.wireshark.org/CaptureSetup"
#ifdef _WIN32
"\n\n"
"Wireless (Wi-Fi/WLAN):\n"
"\n"
"or the mirror at\n"
"\n"
-" http://winpcap.mirror.ethereal.com/\n"
+" http://winpcap.mirror.wireshark.org/\n"
"\n"
"or the mirror at\n"
"\n"
case WTAP_ERR_FILE_UNKNOWN_FORMAT:
/* Seen only when opening a capture file for reading. */
- errmsg = "The file \"%s\" isn't a capture file in a format Tethereal understands.";
+ errmsg = "The file \"%s\" isn't a capture file in a format Twireshark understands.";
break;
case WTAP_ERR_UNSUPPORTED:
/* Seen only when opening a capture file for reading. */
g_snprintf(errmsg_errno, sizeof(errmsg_errno),
- "The file \"%%s\" isn't a capture file in a format Tethereal understands.\n"
+ "The file \"%%s\" isn't a capture file in a format Twireshark understands.\n"
"(%s)", err_info);
g_free(err_info);
errmsg = errmsg_errno;
case WTAP_ERR_UNSUPPORTED_FILE_TYPE:
/* Seen only when opening a capture file for writing. */
- errmsg = "Tethereal doesn't support writing capture files in that format.";
+ errmsg = "Twireshark doesn't support writing capture files in that format.";
break;
case WTAP_ERR_UNSUPPORTED_ENCAP:
if (for_writing)
- errmsg = "Tethereal can't save this capture in that format.";
+ errmsg = "Twireshark can't save this capture in that format.";
else {
g_snprintf(errmsg_errno, sizeof(errmsg_errno),
- "The file \"%%s\" is a capture for a network type that Tethereal doesn't support.\n"
+ "The file \"%%s\" is a capture for a network type that Twireshark doesn't support.\n"
"(%s)", err_info);
g_free(err_info);
errmsg = errmsg_errno;
case WTAP_ERR_ENCAP_PER_PACKET_UNSUPPORTED:
if (for_writing)
- errmsg = "Tethereal can't save this capture in that format.";
+ errmsg = "Twireshark can't save this capture in that format.";
else
- errmsg = "The file \"%s\" is a capture for a network type that Tethereal doesn't support.";
+ errmsg = "The file \"%s\" is a capture for a network type that Twireshark doesn't support.";
break;
case WTAP_ERR_BAD_RECORD:
*
* $Id$
*
- * Ethereal - Network traffic analyzer
+ * Wireshark - Network traffic analyzer
* By Gerald Combs <gerald@wireshark.org>
* Copyright 1998 Gerald Combs
*
g_log(LOG_DOMAIN_CAPTURE_CHILD, G_LOG_LEVEL_DEBUG, "cap_pipe_open_live: %s", pipename);
/*
- * XXX (T)Ethereal blocks until we return
+ * XXX (T)Wireshark blocks until we return
*/
if (strcmp(pipename, "-") == 0)
fd = 0; /* read from stdin */
g_log(LOG_DOMAIN_CAPTURE_CHILD, G_LOG_LEVEL_DEBUG, "capture_loop_open_input : %s", capture_opts->iface);
-/* XXX - opening Winsock on tethereal? */
+/* XXX - opening Winsock on twireshark? */
/* Initialize Windows Socket if we are in a WIN32 OS
This needs to be done before querying the interface for network/netmask */
"\n"
"Help can be found at:\n"
"\n"
-" http://wiki.ethereal.com/CaptureSetup\n"
+" http://wiki.wireshark.org/CaptureSetup\n"
"\n"
"64-bit Windows:\n"
"WinPcap does not support 64-bit Windows; you will have to use some other\n"
/* Pipe doesn't exist, so output message for interface */
/* If we got a "can't find PPA for X" message, warn the user (who
- is running (T)Ethereal on HP-UX) that they don't have a version
+ is running (T)Wireshark on HP-UX) that they don't have a version
of libpcap that properly handles HP-UX (libpcap 0.6.x and later
versions, which properly handle HP-UX, say "can't find /dev/dlpi
PPA for X" rather than "can't find PPA for X"). */
if (strncmp(open_err_str, ppamsg, sizeof ppamsg - 1) == 0)
libpcap_warn =
"\n\n"
- "You are running (T)Ethereal with a version of the libpcap library\n"
+ "You are running (T)Wireshark with a version of the libpcap library\n"
"that doesn't handle HP-UX network devices well; this means that\n"
- "(T)Ethereal may not be able to capture packets.\n"
+ "(T)Wireshark may not be able to capture packets.\n"
"\n"
"To fix this, you should install libpcap 0.6.2, or a later version\n"
"of libpcap, rather than libpcap 0.4 or 0.5.x. It is available in\n"
#endif
}
-/* XXX - will this work for tethereal? */
+/* XXX - will this work for twireshark? */
#ifdef MUST_DO_SELECT
if (!ld->from_cap_pipe) {
#ifdef HAVE_PCAP_GET_SELECTABLE_FD
if (ld->pdh == NULL) {
/* We couldn't set up to write to the capture file. */
- /* XXX - use cf_open_error_message from tethereal instead? */
+ /* XXX - use cf_open_error_message from twireshark instead? */
switch (err) {
case WTAP_ERR_CANT_OPEN:
* to stop a capture until a packet arrives. If that's unacceptable,
* plead with whoever supplies the software for that device to add
* "select()" support, or upgrade to libpcap 0.8.1 or later, and
- * rebuild Ethereal or get a version built with libpcap 0.8.1 or
+ * rebuild Wireshark or get a version built with libpcap 0.8.1 or
* later, so it can use pcap_breakloop().
*/
#ifdef LOG_CAPTURE_VERBOSE
/*
* WinPcap's remote capturing feature doesn't work with pcap_dispatch(),
- * see http://wiki.ethereal.com/CaptureSetup_2fWinPcapRemote
+ * see http://wiki.wireshark.org/CaptureSetup_2fWinPcapRemote
* This should be fixed in the WinPcap 4.0 alpha release.
*
* For reference, an example remote interface:
*
* $Id$
*
- * Ethereal - Network traffic analyzer
+ * Wireshark - Network traffic analyzer
* By Gerald Combs <gerald@wireshark.org>
* Copyright 1998 Gerald Combs
*
typedef void (*capture_packet_cb_fct)(u_char *, const struct pcap_pkthdr *, const u_char *);
-/* moved from capture_loop.c here, so we can combine it (and the related functions) with tethereal */
+/* moved from capture_loop.c here, so we can combine it (and the related functions) with twireshark */
/* XXX - should be moved back to capture_loop.c */
-/* E: capture_loop.c only (Ethereal/dumpcap) T: tethereal only */
+/* E: capture_loop.c only (Wireshark/dumpcap) T: twireshark only */
typedef struct _loop_data {
/* common */
gboolean go; /* TRUE as long as we're supposed to keep capturing */
/*
* If the argument is a number, treat it as an index into the list
- * of adapters, as printed by "tethereal -D".
+ * of adapters, as printed by "twireshark -D".
*
* This should be OK on UNIX systems, as interfaces shouldn't have
* names that begin with digits. It can be useful on Windows, where
/* capture_sync.c
- * Synchronisation between Ethereal capture parent and child instances
+ * Synchronisation between Wireshark capture parent and child instances
*
* $Id$
*
argv = g_malloc(sizeof (char *));
*argv = NULL;
- /* take ethereal's absolute program path and replace "ethereal" with "dumpcap" */
+ /* take Wireshark's absolute program path and replace "Wireshark" with "dumpcap" */
exename = g_strdup_printf("%s" G_DIR_SEPARATOR_S "dumpcap", progfile_dir);
/* Make that the first argument in the argument list (argv[0]). */
if ((capture_opts->fork_child = fork()) == 0) {
/*
- * Child process - run Ethereal with the right arguments to make
+ * Child process - run Wireshark with the right arguments to make
* it just pop up the live capture dialog box and capture with
* the specified capture parameters, writing to the specified file.
*/
}
-/* Ethereal has to exit, force the capture child to close */
+/* Wireshark has to exit, force the capture child to close */
void
sync_pipe_kill(capture_options *capture_opts)
{
/* capture_sync.h
- * Synchronisation between Ethereal capture parent and child instances
+ * Synchronisation between Wireshark capture parent and child instances
*
* $Id$
*
*
* Sync mode capture (internal interface).
*
- * Will start a new Ethereal child instance which will do the actual capture
+ * Will start a new Wireshark child instance which will do the actual capture
* work.
*/
/* capture_wpcap_packet.c
* WinPcap-specific interfaces for low-level information (packet.dll).
* We load WinPcap at run
- * time, so that we only need one Ethereal binary and one Tethereal binary
+ * time, so that we only need one Wireshark binary and one Twireshark binary
* for Windows, regardless of whether WinPcap is installed or not.
*
* $Id$
/* clopts_common.c
- * Handle command-line arguments common to Ethereal and Tethereal
+ * Handle command-line arguments common to Wireshark and Twireshark
*
* $Id$
*
/* clopts_common.h
- * Handle command-line arguments common to Ethereal and Tethereal
+ * Handle command-line arguments common to Wireshark and Twireshark
*
* $Id$
*
/*#define DEBUG_DUMPCAP*/
-gboolean capture_child = FALSE; /* FALSE: standalone call, TRUE: this is an Ethereal capture child */
+gboolean capture_child = FALSE; /* FALSE: standalone call, TRUE: this is an Wireshark capture child */
static void
console_log_handler(const char *log_domain, GLogLevelFlags log_level,
fprintf(output,
"Dumpcap " VERSION "%s\n"
"Capture network packets and dump them into a libpcap file.\n"
- "See http://www.ethereal.com for more information.\n",
+ "See http://www.wireshark.org for more information.\n",
svnversion);
} else {
output = stderr;
"%s\n"
"%s\n"
"%s\n"
- "See http://www.ethereal.com for more information.\n",
+ "See http://www.wireshark.org for more information.\n",
svnversion, get_copyright_info() ,comp_info_str->str, runtime_info_str->str);
}
exit_main(status);
}
break;
- /*** hidden option: Ethereal child mode (using binary output messages) ***/
+ /*** hidden option: Wireshark child mode (using binary output messages) ***/
case 'Z':
capture_child = TRUE;
#ifdef _WIN32
#endif
"\n", VERSION);
fprintf(stderr, "Edit and/or translate the format of capture files.\n");
- fprintf(stderr, "See http://www.ethereal.com for more information.\n");
+ fprintf(stderr, "See http://www.wireshark.org for more information.\n");
fprintf(stderr, "\n");
fprintf(stderr, "Usage: editcap [options] ... <infile> <outfile> [ <packet#>[-<packet#>] ... ]\n");
fprintf(stderr, "\n");
case WTAP_ERR_UNSUPPORTED_ENCAP:
g_snprintf(errmsg_errno, sizeof(errmsg_errno),
- "The capture file has a packet with a network type that Ethereal doesn't support.\n(%s)",
+ "The capture file has a packet with a network type that Wireshark doesn't support.\n(%s)",
err_info);
g_free(err_info);
errmsg = errmsg_errno;
while (to_read != 0 && (wtap_read(cf->wth, err, &err_info, &data_offset))) {
if (cf->state == FILE_READ_ABORTED) {
- /* Well, the user decided to exit Ethereal. Break out of the
+ /* Well, the user decided to exit Wireshark. Break out of the
loop, and let the code below (which is called even if there
aren't any packets left to read) exit. */
break;
packet_list_thaw();
if (cf->state == FILE_READ_ABORTED) {
- /* Well, the user decided to exit Ethereal. Return CF_READ_ABORTED
+ /* Well, the user decided to exit Wireshark. Return CF_READ_ABORTED
so that our caller can kill off the capture child process;
this will cause an EOF on the pipe from the child, so
"cf_finish_tail()" will be called, and it will clean up
case WTAP_ERR_UNSUPPORTED_ENCAP:
g_snprintf(errmsg_errno, sizeof(errmsg_errno),
- "The capture file %%s has a packet with a network type that Ethereal doesn't support.\n(%s)",
+ "The capture file %%s has a packet with a network type that Wireshark doesn't support.\n(%s)",
err_info);
g_free(err_info);
errmsg = errmsg_errno;
these frames, as they won't have been seen by this sequential
pass, but the only alternative I see is to keep scanning them
even though the user requested that the scan stop, and that
- would leave the user stuck with an Ethereal grinding on
+ would leave the user stuck with an Wireshark grinding on
until it finishes. Should we just stick them with that? */
for (; fdata != NULL; fdata = fdata->next) {
fdata->flags.visited = 0;
case WTAP_ERR_RANDOM_OPEN_PIPE:
/* Seen only when opening a capture file for reading. */
simple_dialog(ESD_TYPE_ERROR, ESD_BTN_OK,
- "The file \"%s\" is a pipe or FIFO; Ethereal can't read pipe or FIFO files.",
+ "The file \"%s\" is a pipe or FIFO; Wireshark can't read pipe or FIFO files.",
filename);
break;
case WTAP_ERR_FILE_UNKNOWN_FORMAT:
/* Seen only when opening a capture file for reading. */
simple_dialog(ESD_TYPE_ERROR, ESD_BTN_OK,
- "The file \"%s\" isn't a capture file in a format Ethereal understands.",
+ "The file \"%s\" isn't a capture file in a format Wireshark understands.",
filename);
break;
case WTAP_ERR_UNSUPPORTED:
/* Seen only when opening a capture file for reading. */
simple_dialog(ESD_TYPE_ERROR, ESD_BTN_OK,
- "The file \"%s\" isn't a capture file in a format Ethereal understands.\n"
+ "The file \"%s\" isn't a capture file in a format Wireshark understands.\n"
"(%s)",
filename, err_info);
g_free(err_info);
case WTAP_ERR_UNSUPPORTED_FILE_TYPE:
/* Seen only when opening a capture file for writing. */
simple_dialog(ESD_TYPE_ERROR, ESD_BTN_OK,
- "Ethereal doesn't support writing capture files in that format.");
+ "Wireshark doesn't support writing capture files in that format.");
break;
case WTAP_ERR_UNSUPPORTED_ENCAP:
if (for_writing) {
simple_dialog(ESD_TYPE_ERROR, ESD_BTN_OK,
- "Ethereal can't save this capture in that format.");
+ "Wireshark can't save this capture in that format.");
} else {
simple_dialog(ESD_TYPE_ERROR, ESD_BTN_OK,
- "The file \"%s\" is a capture for a network type that Ethereal doesn't support.\n"
+ "The file \"%s\" is a capture for a network type that Wireshark doesn't support.\n"
"(%s)",
filename, err_info);
g_free(err_info);
case WTAP_ERR_ENCAP_PER_PACKET_UNSUPPORTED:
if (for_writing) {
simple_dialog(ESD_TYPE_ERROR, ESD_BTN_OK,
- "Ethereal can't save this capture in that format.");
+ "Wireshark can't save this capture in that format.");
} else {
simple_dialog(ESD_TYPE_ERROR, ESD_BTN_OK,
- "The file \"%s\" is a capture for a network type that Ethereal doesn't support.",
+ "The file \"%s\" is a capture for a network type that Wireshark doesn't support.",
filename);
}
break;
case WTAP_ERR_UNSUPPORTED_ENCAP:
g_snprintf(errmsg_errno, sizeof(errmsg_errno),
- "The file \"%%s\" has a packet with a network type that Ethereal doesn't support.\n(%s)",
+ "The file \"%%s\" has a packet with a network type that Wireshark doesn't support.\n(%s)",
err_info);
break;
/*
* XXX - "isprint()" can return "true" for non-ASCII characters, but
* those don't work with GTK+ 1.3 or later, as they take UTF-8 strings
- * as input. Until we fix up Ethereal to properly handle non-ASCII
+ * as input. Until we fix up Wireshark to properly handle non-ASCII
* characters in all output (both GUI displays and text printouts)
* in those versions of GTK+, we work around the problem by escaping
* all characters that aren't printable ASCII.
#endif
"\n", VERSION);
fprintf(stderr, "Merge two or more capture files into one.\n");
- fprintf(stderr, "See http://www.ethereal.com for more information.\n");
+ fprintf(stderr, "See http://www.wireshark.org for more information.\n");
fprintf(stderr, "\n");
fprintf(stderr, "Usage: mergecap [options] -w <outfile|-> <infile> ...\n");
fprintf(stderr, "\n");
fputs("\n", output->fh);
fputs("%% the page title\n", output->fh);
ps_clean_string(psbuffer, filename, MAX_PS_LINE_LENGTH);
- fprintf(output->fh, "/eth_pagetitle (%s - Ethereal) def\n", psbuffer);
+ fprintf(output->fh, "/eth_pagetitle (%s - Wireshark) def\n", psbuffer);
fputs("\n", output->fh);
return !ferror(output->fh);
}
while (fgets(buf, BUFFER_SIZE - 1, input)) {
if (state == null) {
- if (strcmp(buf, "% ---- ethereal preamble start ---- %\n") == 0) {
+ if (strcmp(buf, "% ---- wireshark preamble start ---- %\n") == 0) {
state = preamble;
start_code(output, "preamble");
continue;
}
- else if (strcmp(buf, "% ---- ethereal finale start ---- %\n") == 0) {
+ else if (strcmp(buf, "% ---- wireshark finale start ---- %\n") == 0) {
state = finale;
start_code(output, "finale");
continue;
}
}
else if (state == preamble) {
- if (strcmp(buf, "% ---- ethereal preamble end ---- %\n") == 0) {
+ if (strcmp(buf, "% ---- wireshark preamble end ---- %\n") == 0) {
state = null;
end_code(output);
continue;
}
}
else if (state == hex) {
- if (strcmp(buf, "% ---- ethereal hex end ---- %\n") == 0) {
+ if (strcmp(buf, "% ---- wireshark hex end ---- %\n") == 0) {
state = null;
end_code(output);
continue;
}
}
else if (state == finale) {
- if (strcmp(buf, "% ---- ethereal finale end ---- %\n") == 0) {
+ if (strcmp(buf, "% ---- wireshark finale end ---- %\n") == 0) {
state = null;
end_code(output);
continue;
* $Id$
*/
-#ifndef __ETHEREAL_SNPRINTF_H__
-#define __ETHEREAL_SNPRINTF_H__
+#ifndef __WIRESHARK_SNPRINTF_H__
+#define __WIRESHARK_SNPRINTF_H__
#if defined(HAVE_STDARG_H)
# include <stdarg.h>
g_free(ss->filter);
g_free(ss);
- fprintf(stderr, "tethereal: Couldn't register afp,rtt tap: %s\n",
+ fprintf(stderr, "twireshark: Couldn't register afp,rtt tap: %s\n",
error_string->str);
g_string_free(error_string, TRUE);
exit(1);
/* error, we failed to attach to the tap. clean up */
g_free(sp->filter);
g_free(sp);
- fprintf(stderr, "tethereal: Couldn't register dhcp,stat tap: %s\n",
+ fprintf(stderr, "twireshark: Couldn't register dhcp,stat tap: %s\n",
error_string->str);
g_string_free(error_string, TRUE);
exit(1);
filter=NULL;
}
} else {
- fprintf(stderr, "tethereal: invalid \"-z dcerpc,rtt,<uuid>,<major version>.<minor version>[,<filter>]\" argument\n");
+ fprintf(stderr, "twireshark: invalid \"-z dcerpc,rtt,<uuid>,<major version>.<minor version>[,<filter>]\" argument\n");
exit(1);
}
if (major < 0 || major > 65535) {
- fprintf(stderr,"tethereal: dcerpcstat_init() Major version number %d is invalid - must be positive and <= 65535\n", major);
+ fprintf(stderr,"twireshark: dcerpcstat_init() Major version number %d is invalid - must be positive and <= 65535\n", major);
exit(1);
}
if (minor < 0 || minor > 65535) {
- fprintf(stderr,"tethereal: dcerpcstat_init() Minor version number %d is invalid - must be positive and <= 65535\n", minor);
+ fprintf(stderr,"twireshark: dcerpcstat_init() Minor version number %d is invalid - must be positive and <= 65535\n", minor);
exit(1);
}
ver = major;
rs->prog=dcerpc_get_proto_name(&uuid, ver);
if(!rs->prog){
g_free(rs);
- fprintf(stderr,"tethereal: dcerpcstat_init() Protocol with uuid:%08x-%04x-%04x-%02x%02x-%02x%02x%02x%02x%02x%02x v%u not supported\n",uuid.Data1,uuid.Data2,uuid.Data3,uuid.Data4[0],uuid.Data4[1],uuid.Data4[2],uuid.Data4[3],uuid.Data4[4],uuid.Data4[5],uuid.Data4[6],uuid.Data4[7],ver);
+ fprintf(stderr,"twireshark: dcerpcstat_init() Protocol with uuid:%08x-%04x-%04x-%02x%02x-%02x%02x%02x%02x%02x%02x v%u not supported\n",uuid.Data1,uuid.Data2,uuid.Data3,uuid.Data4[0],uuid.Data4[1],uuid.Data4[2],uuid.Data4[3],uuid.Data4[4],uuid.Data4[5],uuid.Data4[6],uuid.Data4[7],ver);
exit(1);
}
procs=dcerpc_get_proto_sub_dissector(&uuid, ver);
g_free(rs->filter);
g_free(rs);
- fprintf(stderr, "tethereal: Couldn't register dcerpc,rtt tap: %s\n",
+ fprintf(stderr, "twireshark: Couldn't register dcerpc,rtt tap: %s\n",
error_string->str);
g_string_free(error_string, TRUE);
exit(1);
/* tap_h225counter.c
- * h225 message counter for ethereal
+ * h225 message counter for wireshark
* Copyright 2003 Lars Roland
*
* $Id$
g_free(hs->filter);
g_free(hs);
- fprintf(stderr, "tethereal: Couldn't register h225,counter tap: %s\n",
+ fprintf(stderr, "twireshark: Couldn't register h225,counter tap: %s\n",
error_string->str);
g_string_free(error_string, TRUE);
exit(1);
/* tap_h225rassrt.c
- * h225 RAS Service Response Time statistics for ethereal
+ * h225 RAS Service Response Time statistics for wireshark
* Copyright 2003 Lars Roland
*
* $Id$
g_free(hs->filter);
g_free(hs);
- fprintf(stderr, "tethereal: Couldn't register h225,srt tap: %s\n",
+ fprintf(stderr, "twireshark: Couldn't register h225,srt tap: %s\n",
error_string->str);
g_string_free(error_string, TRUE);
exit(1);
/* error, we failed to attach to the tap. clean up */
g_free(sp->filter);
g_free(sp);
- fprintf (stderr, "tethereal: Couldn't register http,stat tap: %s\n",
+ fprintf (stderr, "twireshark: Couldn't register http,stat tap: %s\n",
error_string->str);
g_string_free(error_string, TRUE);
exit(1);
p=filter+namelen+1;
parenp=strchr(p, ')');
if(!parenp){
- fprintf(stderr, "tethereal: Closing parenthesis missing from calculated expression.\n");
+ fprintf(stderr, "twireshark: Closing parenthesis missing from calculated expression.\n");
exit(10);
}
/* bail out if there was no field specified */
if(parenp==p){
- fprintf(stderr, "tethereal: You didn't specify a field name for %s(*).\n",
+ fprintf(stderr, "twireshark: You didn't specify a field name for %s(*).\n",
calc_type_table[j].func_name);
exit(10);
}
field=malloc(parenp-p+1);
if(!field){
- fprintf(stderr, "tethereal: Out of memory.\n");
+ fprintf(stderr, "twireshark: Out of memory.\n");
exit(10);
}
memcpy(field, p, parenp-p);
hfi=proto_registrar_get_byname(field);
if(!hfi){
- fprintf(stderr, "tethereal: There is no field named '%s'.\n",
+ fprintf(stderr, "twireshark: There is no field named '%s'.\n",
field);
free(field);
exit(10);
break;
default:
fprintf(stderr,
- "tethereal: %s is a relative-time field, so %s(*) calculations are not supported on it.",
+ "twireshark: %s is a relative-time field, so %s(*) calculations are not supported on it.",
field,
calc_type_table[j].func_name);
exit(10);
*/
if(io->items[i].calc_type!=CALC_TYPE_COUNT){
fprintf(stderr,
- "tethereal: %s is a 64-bit integer, so %s(*) calculations are not supported on it.",
+ "twireshark: %s is a 64-bit integer, so %s(*) calculations are not supported on it.",
field,
calc_type_table[j].func_name);
exit(10);
*/
if(io->items[i].calc_type!=CALC_TYPE_COUNT){
fprintf(stderr,
- "tethereal: %s doesn't have integral values, so %s(*) calculations are not supported on it.\n",
+ "twireshark: %s doesn't have integral values, so %s(*) calculations are not supported on it.\n",
field,
calc_type_table[j].func_name);
exit(10);
if(error_string){
g_free(io->items);
g_free(io);
- fprintf(stderr, "tethereal: Couldn't register io,stat tap: %s\n",
+ fprintf(stderr, "twireshark: Couldn't register io,stat tap: %s\n",
error_string->str);
g_string_free(error_string, TRUE);
exit(1);
filter=NULL;
}
} else {
- fprintf(stderr, "tethereal: invalid \"-z io,stat,<interval>[,<filter>]\" argument\n");
+ fprintf(stderr, "twireshark: invalid \"-z io,stat,<interval>[,<filter>]\" argument\n");
exit(1);
}
/* make interval be number of ms */
interval=(gint32)(interval_float*1000.0+0.9);
if(interval<1){
- fprintf(stderr, "tethereal: \"-z\" interval must be >=0.001 seconds.\n");
+ fprintf(stderr, "twireshark: \"-z\" interval must be >=0.001 seconds.\n");
exit(10);
}
tap_type_name="SCTP";
packet_func=iousers_sctp_packet;
} else {
- fprintf(stderr, "tethereal: invalid \"-z conv,<type>[,<filter>]\" argument\n");
+ fprintf(stderr, "twireshark: invalid \"-z conv,<type>[,<filter>]\" argument\n");
fprintf(stderr," <type> must be one of\n");
fprintf(stderr," \"eth\"\n");
fprintf(stderr," \"fc\"\n");
g_free(iu->items);
}
g_free(iu);
- fprintf(stderr, "tethereal: Couldn't register conversations tap: %s\n",
+ fprintf(stderr, "twireshark: Couldn't register conversations tap: %s\n",
error_string->str);
g_string_free(error_string, TRUE);
exit(1);
g_free(ms->filter);
g_free(ms);
- fprintf(stderr, "tethereal: Couldn't register mgcp,rtd tap: %s\n",
+ fprintf(stderr, "twireshark: Couldn't register mgcp,rtd tap: %s\n",
error_string->str);
g_string_free(error_string, TRUE);
exit(1);
* Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
*/
-/* This module provides Protocol Column Info tap for tethereal */
+/* This module provides Protocol Column Info tap for twireshark */
#ifdef HAVE_CONFIG_H
# include "config.h"
* and, if so, we report that error and exit.
*/
if (pinfo->cinfo == NULL) {
- fprintf(stderr, "tethereal: the proto,colinfo tap doesn't work if the columns aren't being printed.\n");
+ fprintf(stderr, "twireshark: the proto,colinfo tap doesn't work if the columns aren't being printed.\n");
exit(1);
}
gp=proto_get_finfo_ptr_array(edt->tree, rs->hf_index);
}
}
if(!field){
- fprintf(stderr, "tethereal: invalid \"-z proto,colinfo,<filter>,<field>\" argument\n");
+ fprintf(stderr, "twireshark: invalid \"-z proto,colinfo,<filter>,<field>\" argument\n");
exit(1);
}
hfi=proto_registrar_get_byname(field);
if(!hfi){
- fprintf(stderr, "tethereal: Field \"%s\" doesn't exist.\n", field);
+ fprintf(stderr, "twireshark: Field \"%s\" doesn't exist.\n", field);
exit(1);
}
error_string=register_tap_listener("frame", rs, rs->filter, NULL, protocolinfo_packet, NULL);
if(error_string){
/* error, we failed to attach to the tap. complain and clean up */
- fprintf(stderr, "tethereal: Couldn't register proto,colinfo tap: %s\n",
+ fprintf(stderr, "twireshark: Couldn't register proto,colinfo tap: %s\n",
error_string->str);
g_string_free(error_string, TRUE);
if(rs->filter){
* Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
*/
-/* This module provides ProtocolHierarchyStatistics for tethereal */
+/* This module provides ProtocolHierarchyStatistics for twireshark */
#ifdef HAVE_CONFIG_H
# include "config.h"
filter="frame";
}
} else {
- fprintf(stderr, "tethereal: invalid \"-z io,phs[,<filter>]\" argument\n");
+ fprintf(stderr, "twireshark: invalid \"-z io,phs[,<filter>]\" argument\n");
exit(1);
}
g_free(rs->filter);
g_free(rs);
- fprintf(stderr, "tethereal: Couldn't register io,phs tap: %s\n",
+ fprintf(stderr, "twireshark: Couldn't register io,phs tap: %s\n",
error_string->str);
g_string_free(error_string, TRUE);
exit(1);
* Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
*/
-/* This module provides rpc call/reply SRT statistics to tethereal.
- * It is only used by tethereal and not ethereal
+/* This module provides rpc call/reply SRT statistics to twireshark.
+ * It is only used by twireshark and not wireshark
*/
#ifdef HAVE_CONFIG_H
error_string=register_tap_listener("rpc", NULL, NULL, NULL, rpcprogs_packet, rpcprogs_draw);
if(error_string){
- fprintf(stderr,"tethereal: Couldn't register rpc,programs tap: %s\n",
+ fprintf(stderr,"twireshark: Couldn't register rpc,programs tap: %s\n",
error_string->str);
g_string_free(error_string, TRUE);
exit(1);
* Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
*/
-/* This module provides rpc call/reply RTT statistics to tethereal.
- * It is only used by tethereal and not ethereal
+/* This module provides rpc call/reply RTT statistics to twireshark.
+ * It is only used by twireshark and not wireshark
*
* It serves as an example on how to use the tap api.
*/
-/* This callback is never used by tethereal but it is here for completeness.
+/* This callback is never used by twireshark but it is here for completeness.
* When registering below, we could just have left this function as NULL.
*
* When used by wireshark, this function will be called whenever we would need
- * to reset all state. Such as when ethereal opens a new file, when it
+ * to reset all state. Such as when wireshark opens a new file, when it
* starts a new capture, when it rescans the packetlist after some prefs have
* changed etc.
* So if your aplication has some state it needs to clean up in those
* later.
*
* This function should be as lightweight as possible since it executes together
- * with the normal ethereal dissectors. Try to push as much processing as
+ * with the normal wireshark dissectors. Try to push as much processing as
* possible into (*draw) instead since that function executes asynchronously
* and does not affect the main threads performance.
*
return 1;
}
-/* This callback is used when tethereal wants us to draw/update our
- * data to the output device. Since this is tethereal only output is
+/* This callback is used when twireshark wants us to draw/update our
+ * data to the output device. Since this is twireshark only output is
* stdout.
- * Tethereal will only call this callback once, which is when tethereal has
+ * Twireshark will only call this callback once, which is when twireshark has
* finished reading all packets and exists.
* If used with wireshark this may be called any time, perhaps once every 3
* seconds or so.
/* When called, this function will create a new instance of rpcstat.
* program and version are whick onc-rpc program/version we want to
* collect statistics for.
- * This function is called from tethereal when it parses the -z rpc, arguments
+ * This function is called from twireshark when it parses the -z rpc, arguments
* and it creates a new instance to store statistics in and registers this
* new instance for the rpc tap.
*/
filter=NULL;
}
} else {
- fprintf(stderr, "t
ethereal: invalid \"-z rpc,rtt,<program>,<version>[,<filter>]\" argument\n");
+ fprintf(stderr, "t
wireshark: invalid \"-z rpc,rtt,<program>,<version>[,<filter>]\" argument\n");
exit(1);
}
rpc_max_proc=-1;
g_hash_table_foreach(rpc_procs, (GHFunc)rpcstat_find_procs, NULL);
if(rpc_min_proc==-1){
- fprintf(stderr,"tethereal: Invalid -z rpc,rrt,%d,%d\n",rpc_program,rpc_version);
- fprintf(stderr," Program:%d version:%d isn't supported by tethereal.\n", rpc_program, rpc_version);
+ fprintf(stderr,"twireshark: Invalid -z rpc,rrt,%d,%d\n",rpc_program,rpc_version);
+ fprintf(stderr," Program:%d version:%d isn't supported by twireshark.\n", rpc_program, rpc_version);
exit(1);
}
g_free(rs->filter);
g_free(rs);
- fprintf(stderr, "tethereal: Couldn't register rpc,rtt tap: %s\n",
+ fprintf(stderr, "twireshark: Couldn't register rpc,rtt tap: %s\n",
error_string->str);
g_string_free(error_string, TRUE);
exit(1);
/* tap_sctpchunkstat.c
- * SCTP chunk counter for ethereal
+ * SCTP chunk counter for wireshark
* Copyright 2005 Oleg Terletsky <oleg.terletsky@comverse.com>
*
* $Id$
g_free(hs->filter);
g_free(hs);
- fprintf(stderr, "tethereal: Couldn't register sctp,stat tap: %s\n",
+ fprintf(stderr, "twireshark: Couldn't register sctp,stat tap: %s\n",
error_string->str);
g_string_free(error_string, TRUE);
exit(1);
/* tap_sipstat.c
- * sip message counter for ethereal
+ * sip message counter for wireshark
*
* $Id$
* Copied from gtk/sip_stat.c and tap-httpstat.c
/* error, we failed to attach to the tap. clean up */
g_free(sp->filter);
g_free(sp);
- fprintf (stderr, "tethereal: Couldn't register sip,stat tap: %s\n",
+ fprintf (stderr, "twireshark: Couldn't register sip,stat tap: %s\n",
error_string->str);
g_string_free(error_string, TRUE);
exit(1);
fprintf(stderr,"Either enable Edit/Preferences/Protocols/SMB/Snoop SID name mappings in wireshark\n");
fprintf(stderr,"or override the preference file by specifying\n");
fprintf(stderr," -o \"smb.sid_name_snooping=TRUE\"\n");
- fprintf(stderr,"on the tethereal command line.\n");
+ fprintf(stderr,"on the twireshark command line.\n");
exit(1);
}
error_string=register_tap_listener("smb", NULL, NULL, NULL, smbsids_packet, smbsids_draw);
if(error_string){
- fprintf(stderr, "tethereal: Couldn't register smb,sids tap:%s\n",
+ fprintf(stderr, "twireshark: Couldn't register smb,sids tap:%s\n",
error_string->str);
g_string_free(error_string, TRUE);
exit(1);
g_free(ss->filter);
g_free(ss);
- fprintf(stderr, "tethereal: Couldn't register smb,rtt tap: %s\n",
+ fprintf(stderr, "twireshark: Couldn't register smb,rtt tap: %s\n",
error_string->str);
g_string_free(error_string, TRUE);
exit(1);
/* tap-stats_tree.c
- * tethereal's tap implememntation of stats_tree
+ * twireshark's tap implememntation of stats_tree
* 2005, Luis E. G. Ontanon
*
* $Id$
* Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
*/
-/* This module provides WSP statistics to tethereal.
- * It is only used by tethereal and not ethereal
+/* This module provides WSP statistics to twireshark.
+ * It is only used by twireshark and not wireshark
*
*/
}
-/* This callback is used when tethereal wants us to draw/update our
- * data to the output device. Since this is tethereal only output is
+/* This callback is used when twireshark wants us to draw/update our
+ * data to the output device. Since this is twireshark only output is
* stdout.
- * Tethereal will only call this callback once, which is when tethereal has
+ * Twireshark will only call this callback once, which is when twireshark has
* finished reading all packets and exists.
* If used with wireshark this may be called any time, perhaps once every 3
* seconds or so.
/* When called, this function will create a new instance of wspstat.
* program and version are whick onc-rpc program/version we want to
* collect statistics for.
- * This function is called from tethereal when it parses the -z wsp, arguments
+ * This function is called from twireshark when it parses the -z wsp, arguments
* and it creates a new instance to store statistics in and registers this
* new instance for the wsp tap.
*/
g_free(sp);
g_hash_table_foreach( sp->hash, (GHFunc) wsp_free_hash_table, NULL ) ;
g_hash_table_destroy( sp->hash );
- fprintf(stderr, "tethereal: Couldn't register wsp,stat tap: %s\n",
+ fprintf(stderr, "twireshark: Couldn't register wsp,stat tap: %s\n",
error_string->str);
g_string_free(error_string, TRUE);
exit(1);
-/* tethereal.c
+/* twireshark.c
*
* $Id$
*
if (print_ver) {
output = stdout;
fprintf(output,
- "Tethereal " VERSION "%s\n"
+ "Twireshark " VERSION "%s\n"
"Dump and analyze network traffic.\n"
- "See http://www.ethereal.com for more information.\n"
+ "See http://www.wireshark.com for more information.\n"
"\n"
"%s",
svnversion, get_copyright_info());
output = stderr;
}
fprintf(output, "\n");
- fprintf(output, "Usage: tethereal [options] ...\n");
+ fprintf(output, "Usage: twireshark [options] ...\n");
fprintf(output, "\n");
#ifdef HAVE_LIBPCAP
}
break;
case 'v': /* Show version and exit */
- printf("Tethereal " VERSION "%s\n"
+ printf("Twireshark " VERSION "%s\n"
"\n"
"%s"
"\n"
#ifndef HAVE_LIBPCAP
if (capture_option_specified)
- cmdarg_err("This version of Tethereal was not built with support for capturing packets.");
+ cmdarg_err("This version of Twireshark was not built with support for capturing packets.");
#endif
if (arg_error) {
print_usage(FALSE);
/*
* Immediately relinquish any special privileges we have; we must not
- * be allowed to read any capture files the user running Tethereal
+ * be allowed to read any capture files the user running Twireshark
* can't open.
*/
relinquish_special_privs_perm();
char *detailed_err;
cmdarg_err("WinPcap couldn't be found.");
- detailed_err = cant_load_winpcap_err("Tethereal");
+ detailed_err = cant_load_winpcap_err("Twireshark");
cmdarg_err_cont("%s", detailed_err);
g_free(detailed_err);
exit(2);
}
#else
/* No - complain. */
- cmdarg_err("This version of Tethereal was not built with support for capturing packets.");
+ cmdarg_err("This version of Twireshark was not built with support for capturing packets.");
exit(2);
#endif
}
no other handler - such as one that would terminate the process -
gets called.
- XXX - for some reason, typing ^C to Tethereal, if you run this in
+ XXX - for some reason, typing ^C to Twireshark, if you run this in
a Cygwin console window in at least some versions of Cygwin,
- causes Tethereal to terminate immediately; this routine gets
+ causes Twireshark to terminate immediately; this routine gets
called, but the main loop doesn't get a chance to run and
exit cleanly, at least if this is compiled with Microsoft Visual
C++ (i.e., it's a property of the Cygwin console window or Bash;
- it happens if Tethereal is not built with Cygwin - for all I know,
+ it happens if Twireshark is not built with Cygwin - for all I know,
building it with Cygwin may make the problem go away). */
ld.go = FALSE;
return TRUE;
switch (err) {
case WTAP_ERR_UNSUPPORTED_ENCAP:
- cmdarg_err("\"%s\" has a packet with a network type that Tethereal doesn't support.\n(%s)",
+ cmdarg_err("\"%s\" has a packet with a network type that Twireshark doesn't support.\n(%s)",
cf->filename, err_info);
break;
tree for a single packet without waiting for anything to happen,
it should be as good as line-buffered mode if we're printing
protocol trees. (The whole reason for the "-l" flag in either
- tcpdump or Tethereal is to allow the output of a live capture to
+ tcpdump or Twireshark is to allow the output of a live capture to
be piped to a program or script and to have that script see the
information for the packet as soon as it's printed, rather than
having to wait until a standard I/O buffer fills up. */
case WTAP_ERR_FILE_UNKNOWN_FORMAT:
/* Seen only when opening a capture file for reading. */
- errmsg = "The file \"%s\" isn't a capture file in a format Tethereal understands.";
+ errmsg = "The file \"%s\" isn't a capture file in a format Twireshark understands.";
break;
case WTAP_ERR_UNSUPPORTED:
/* Seen only when opening a capture file for reading. */
g_snprintf(errmsg_errno, sizeof(errmsg_errno),
- "The file \"%%s\" isn't a capture file in a format Tethereal understands.\n"
+ "The file \"%%s\" isn't a capture file in a format Twireshark understands.\n"
"(%s)", err_info);
g_free(err_info);
errmsg = errmsg_errno;
case WTAP_ERR_UNSUPPORTED_FILE_TYPE:
/* Seen only when opening a capture file for writing. */
- errmsg = "Tethereal doesn't support writing capture files in that format.";
+ errmsg = "Twireshark doesn't support writing capture files in that format.";
break;
case WTAP_ERR_UNSUPPORTED_ENCAP:
if (for_writing)
- errmsg = "Tethereal can't save this capture in that format.";
+ errmsg = "Twireshark can't save this capture in that format.";
else {
g_snprintf(errmsg_errno, sizeof(errmsg_errno),
- "The file \"%%s\" is a capture for a network type that Tethereal doesn't support.\n"
+ "The file \"%%s\" is a capture for a network type that Twireshark doesn't support.\n"
"(%s)", err_info);
g_free(err_info);
errmsg = errmsg_errno;
case WTAP_ERR_ENCAP_PER_PACKET_UNSUPPORTED:
if (for_writing)
- errmsg = "Tethereal can't save this capture in that format.";
+ errmsg = "Twireshark can't save this capture in that format.";
else
- errmsg = "The file \"%s\" is a capture for a network type that Tethereal doesn't support.";
+ errmsg = "The file \"%s\" is a capture for a network type that Twireshark doesn't support.";
break;
case WTAP_ERR_BAD_RECORD:
}
/*
- * Open/create errors are reported with an console message in Tethereal.
+ * Open/create errors are reported with an console message in Twireshark.
*/
static void
open_failure_message(const char *filename, int err, gboolean for_writing)
{
- fprintf(stderr, "tethereal: ");
+ fprintf(stderr, "twireshark: ");
fprintf(stderr, file_open_error_message(err, for_writing), filename);
fprintf(stderr, "\n");
}
/*
- * General errors are reported with an console message in Tethereal.
+ * General errors are reported with an console message in Twireshark.
*/
static void
failure_message(const char *msg_format, va_list ap)
{
- fprintf(stderr, "tethereal: ");
+ fprintf(stderr, "twireshark: ");
vfprintf(stderr, msg_format, ap);
fprintf(stderr, "\n");
}
/*
- * Read errors are reported with an console message in Tethereal.
+ * Read errors are reported with an console message in Twireshark.
*/
static void
read_failure_message(const char *filename, int err)
va_list ap;
va_start(ap, fmt);
- fprintf(stderr, "tethereal: ");
+ fprintf(stderr, "twireshark: ");
vfprintf(stderr, fmt, ap);
fprintf(stderr, "\n");
va_end(ap);
#endif
"\n"
"Generate a capture file from an ASCII hexdump of packets.\n"
- "See http://www.ethereal.com for more information.\n"
+ "See http://www.wireshark.org for more information.\n"
"\n"
"Usage: text2pcap [options] <input-filename> <output-filename>\n"
"\n"
* flavor of Windows on which you're running. Implementing more
* of that is left as an exercise to the reader - who should
* check any copyright information about code samples on MSDN
- * before cutting and pasting into Ethereal.
+ * before cutting and pasting into Wireshark.
*
* They should also note that you need an OSVERSIONINFOEX structure
* to get some of that information, and that not only is that
git.samba.org / obnox / wireshark / wip.git / commitdiff