/* * XXX - the routine pointed to by "print_line_fcn_p" doesn't get handed lines, * it gets handed bufferfuls. That's fine for "follow_write_raw()" * and "follow_add_to_gtk_text()", but, as "follow_print_text()" calls * the "print_line()" routine from "print.c", and as that routine might * genuinely expect to be handed a line (if, for example, it's using * some OS or desktop environment's printing API, and that API expects * to be handed lines), "follow_print_text()" should probably accumulate * lines in a buffer and hand them "print_line()". (If there's a * complete line in a buffer - i.e., there's nothing of the line in * the previous buffer or the next buffer - it can just hand that to * "print_line()" after filtering out non-printables, as an * optimization.) * * This might or might not be the reason why C arrays display * correctly but get extra blank lines very other line when printed. */ static frs_return_t follow_common_read_stream(follow_info_t *follow_info, follow_print_line_func follow_print, void *arg) { guint32 global_client_pos = 0, global_server_pos = 0; guint32 server_packet_count = 0; guint32 client_packet_count = 0; guint32 *global_pos; gboolean skip; GList* cur; frs_return_t frs_return; follow_record_t *follow_record; char *buffer; for (cur = follow_info->payload; cur; cur = g_list_next(cur)) { follow_record = (follow_record_t *)cur->data; skip = FALSE; if (!follow_record->is_server) { global_pos = &global_client_pos; if(follow_info->show_stream == FROM_SERVER) { skip = TRUE; } } else { global_pos = &global_server_pos; if (follow_info->show_stream == FROM_CLIENT) { skip = TRUE; } } if (!skip) { buffer = (char *)g_memdup(follow_record->data->data, follow_record->data->len); frs_return = follow_show(follow_info, follow_print, buffer, follow_record->data->len, follow_record->is_server, arg, global_pos, &server_packet_count, &client_packet_count); g_free(buffer); if(frs_return == FRS_PRINT_ERROR) return frs_return; } } return FRS_OK; }
/* * XXX - the routine pointed to by "print_line_fcn_p" doesn't get handed lines, * it gets handed bufferfuls. That's fine for "follow_write_raw()" * and "follow_add_to_gtk_text()", but, as "follow_print_text()" calls * the "print_line()" routine from "print.c", and as that routine might * genuinely expect to be handed a line (if, for example, it's using * some OS or desktop environment's printing API, and that API expects * to be handed lines), "follow_print_text()" should probably accumulate * lines in a buffer and hand them "print_line()". (If there's a * complete line in a buffer - i.e., there's nothing of the line in * the previous buffer or the next buffer - it can just hand that to * "print_line()" after filtering out non-printables, as an * optimization.) * * This might or might not be the reason why C arrays display * correctly but get extra blank lines very other line when printed. */ frs_return_t FollowStreamDialog::follow_read_udp_stream() { guint32 global_client_pos = 0, global_server_pos = 0; guint32 *global_pos; gboolean skip; GList* cur; frs_return_t frs_return; follow_record_t *follow_record; char *buffer; for (cur = follow_info_.payload; cur; cur = g_list_next(cur)) { follow_record = (follow_record_t *)cur->data; skip = FALSE; if (!follow_record->is_server) { global_pos = &global_client_pos; if(follow_info_.show_stream == FROM_SERVER) { skip = TRUE; } } else { global_pos = &global_server_pos; if (follow_info_.show_stream == FROM_CLIENT) { skip = TRUE; } } if (!skip) { buffer = (char *)g_memdup(follow_record->data->data, follow_record->data->len); frs_return = follow_show( buffer, follow_record->data->len, follow_record->is_server, follow_record->packet_num, global_pos); g_free(buffer); if(frs_return == FRS_PRINT_ERROR) return frs_return; } } return FRS_OK; }
/* * XXX - the routine pointed to by "print_line_fcn_p" doesn't get handed lines, * it gets handed bufferfuls. That's fine for "follow_write_raw()" * and "follow_add_to_gtk_text()", but, as "follow_print_text()" calls * the "print_line()" routine from "print.c", and as that routine might * genuinely expect to be handed a line (if, for example, it's using * some OS or desktop environment's printing API, and that API expects * to be handed lines), "follow_print_text()" should probably accumulate * lines in a buffer and hand them "print_line()". (If there's a * complete line in a buffer - i.e., there's nothing of the line in * the previous buffer or the next buffer - it can just hand that to * "print_line()" after filtering out non-printables, as an * optimization.) * * This might or might not be the reason why C arrays display * correctly but get extra blank lines very other line when printed. */ frs_return_t FollowStreamDialog::follow_read_ssl_stream() { guint32 global_client_pos = 0, global_server_pos = 0; guint32 * global_pos; GList * cur; frs_return_t frs_return; for (cur = follow_info_.payload; cur; cur = g_list_next(cur)) { SslDecryptedRecord * rec = (SslDecryptedRecord*) cur->data; gboolean include_rec = FALSE; if (rec->is_from_server) { global_pos = &global_server_pos; include_rec = (follow_info_.show_stream == BOTH_HOSTS) || (follow_info_.show_stream == FROM_SERVER); } else { global_pos = &global_client_pos; include_rec = (follow_info_.show_stream == BOTH_HOSTS) || (follow_info_.show_stream == FROM_CLIENT); } if (include_rec) { size_t nchars = rec->data.data_len; gchar *buffer = (gchar *)g_memdup(rec->data.data, (guint) nchars); frs_return = follow_show(buffer, nchars, rec->is_from_server, rec->packet_num, global_pos); g_free(buffer); if (frs_return == FRS_PRINT_ERROR) return frs_return; } } return FRS_OK; }
/* * XXX - the routine pointed to by "print_line_fcn_p" doesn't get handed lines, * it gets handed bufferfuls. That's fine for "follow_write_raw()" * and "follow_add_to_gtk_text()", but, as "follow_print_text()" calls * the "print_line()" routine from "print.c", and as that routine might * genuinely expect to be handed a line (if, for example, it's using * some OS or desktop environment's printing API, and that API expects * to be handed lines), "follow_print_text()" should probably accumulate * lines in a buffer and hand them "print_line()". (If there's a * complete line in a buffer - i.e., there's nothing of the line in * the previous buffer or the next buffer - it can just hand that to * "print_line()" after filtering out non-printables, as an * optimization.) * * This might or might not be the reason why C arrays display * correctly but get extra blank lines very other line when printed. */ frs_return_t FollowStreamDialog::follow_read_tcp_stream() { FILE *data_out_fp; tcp_stream_chunk sc; size_t bcount; size_t bytes_read; int iplen; guint8 client_addr[MAX_IPADDR_LEN]; guint16 client_port = 0; gboolean is_server; guint32 global_client_pos = 0, global_server_pos = 0; guint32 *global_pos; gboolean skip; char buffer[FLT_BUF_SIZE+1]; /* +1 to fix ws bug 1043 */ size_t nchars; frs_return_t frs_return; iplen = (follow_info_.is_ipv6) ? 16 : 4; data_out_fp = ws_fopen(data_out_filename_.toUtf8().constData(), "rb"); if (data_out_fp == NULL) { QMessageBox::critical(this, "Error", "Could not open temporary file %1: %2", data_out_filename_, g_strerror(errno)); return FRS_OPEN_ERROR; } while ((nchars=fread(&sc, 1, sizeof(sc), data_out_fp))) { if (nchars != sizeof(sc)) { QMessageBox::critical(this, "Error", QString(tr("Short read from temporary file %1: expected %2, got %3")) .arg(data_out_filename_) .arg(sizeof(sc)) .arg(nchars)); fclose(data_out_fp); data_out_fp = NULL; return FRS_READ_ERROR; } if (client_port == 0) { memcpy(client_addr, sc.src_addr, iplen); client_port = sc.src_port; } skip = FALSE; if (memcmp(client_addr, sc.src_addr, iplen) == 0 && client_port == sc.src_port) { is_server = FALSE; global_pos = &global_client_pos; if (follow_info_.show_stream == FROM_SERVER) { skip = TRUE; } } else { is_server = TRUE; global_pos = &global_server_pos; if (follow_info_.show_stream == FROM_CLIENT) { skip = TRUE; } } bytes_read = 0; while (bytes_read < sc.dlen) { bcount = ((sc.dlen-bytes_read) < FLT_BUF_SIZE) ? (sc.dlen-bytes_read) : FLT_BUF_SIZE; nchars = fread(buffer, 1, bcount, data_out_fp); if (nchars == 0) break; /* XXX - if we don't get "bcount" bytes, is that an error? */ bytes_read += nchars; if (!skip) { frs_return = follow_show(buffer, nchars, is_server, sc.packet_num, global_pos); if(frs_return == FRS_PRINT_ERROR) { fclose(data_out_fp); data_out_fp = NULL; return frs_return; } } } } if (ferror(data_out_fp)) { QMessageBox::critical(this, tr("Error reading temporary file"), QString("%1: %2").arg(data_out_filename_).arg(g_strerror(errno))); fclose(data_out_fp); data_out_fp = NULL; return FRS_READ_ERROR; } fclose(data_out_fp); data_out_fp = NULL; return FRS_OK; }