libfreerdp-utils/pcap.c

   1 /**
   2  * FreeRDP: A Remote Desktop Protocol Client
   3  * pcap File Format Utils
   4  *
   5  * Copyright 2011 Marc-Andre Moreau <marcandre.moreau@gmail.com>
   6  *
   7  * Licensed under the Apache License, Version 2.0 (the "License");
   8  * you may not use this file except in compliance with the License.
   9  * You may obtain a copy of the License at
  10  *
  11  *     http://www.apache.org/licenses/LICENSE-2.0
  12  *
  13  * Unless required by applicable law or agreed to in writing, software
  14  * distributed under the License is distributed on an "AS IS" BASIS,
  15  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  16  * See the License for the specific language governing permissions and
  17  * limitations under the License.
  18  */
  19
  20 #include <stdio.h>
  21 #include <string.h>
  22
  23 #ifndef _WIN32
  24 #include <sys/time.h>
  25 #else
  26 #include <time.h>
  27 #include <sys/timeb.h>
  28
  29 #if !defined(__MINGW32__) && !defined(__MINGW64__)
  30 struct timeval
  31 {
  32         long tv_sec;
  33         long tv_usec;
  34 };
  35 #endif
  36
  37 int gettimeofday(struct timeval* tp, void* tz)
  38 {
  39         struct _timeb timebuffer;
  40         _ftime (&timebuffer);
  41         tp->tv_sec = (long) timebuffer.time;
  42         tp->tv_usec = timebuffer.millitm * 1000;
  43         return 0;
  44 }
  45 #endif
  46
  47 #include <freerdp/types.h>
  48 #include <freerdp/utils/memory.h>
  49
  50 #include <freerdp/utils/pcap.h>
  51
  52 #define PCAP_MAGIC      0xA1B2C3D4
  53
  54 void pcap_read_header(rdpPcap* pcap, pcap_header* header)
  55 {
  56         fread((void*) header, sizeof(pcap_header), 1, pcap->fp);
  57 }
  58
  59 void pcap_write_header(rdpPcap* pcap, pcap_header* header)
  60 {
  61         fwrite((void*) header, sizeof(pcap_header), 1, pcap->fp);
  62 }
  63
  64 void pcap_read_record_header(rdpPcap* pcap, pcap_record_header* record)
  65 {
  66         fread((void*) record, sizeof(pcap_record_header), 1, pcap->fp);
  67 }
  68
  69 void pcap_write_record_header(rdpPcap* pcap, pcap_record_header* record)
  70 {
  71         fwrite((void*) record, sizeof(pcap_record_header), 1, pcap->fp);
  72 }
  73
  74 void pcap_read_record(rdpPcap* pcap, pcap_record* record)
  75 {
  76         pcap_read_record_header(pcap, &record->header);
  77         record->length = record->header.incl_len;
  78         record->data = xmalloc(record->length);
  79         fread(record->data, record->length, 1, pcap->fp);
  80 }
  81
  82 void pcap_write_record(rdpPcap* pcap, pcap_record* record)
  83 {
  84         pcap_write_record_header(pcap, &record->header);
  85         fwrite(record->data, record->length, 1, pcap->fp);
  86 }
  87
  88 void pcap_add_record(rdpPcap* pcap, void* data, uint32 length)
  89 {
  90         pcap_record* record;
  91         struct timeval tp;
  92
  93         if (pcap->tail == NULL)
  94         {
  95                 pcap->tail = (pcap_record*) xzalloc(sizeof(pcap_record));
  96                 pcap->head = pcap->tail;
  97                 pcap->record = pcap->head;
  98                 record = pcap->tail;
  99         }
 100         else
 101         {
 102                 record = (pcap_record*) xzalloc(sizeof(pcap_record));
 103                 pcap->tail->next = record;
 104                 pcap->tail = record;
 105         }
 106
 107         if (pcap->record == NULL)
 108                 pcap->record = record;
 109
 110         record->data = data;
 111         record->length = length;
 112         record->header.incl_len = length;
 113         record->header.orig_len = length;
 114
 115         gettimeofday(&tp, 0);
 116         record->header.ts_sec = tp.tv_sec;
 117         record->header.ts_usec = tp.tv_usec;
 118 }
 119
 120 boolean pcap_has_next_record(rdpPcap* pcap)
 121 {
 122         if (pcap->file_size - (ftell(pcap->fp)) <= 16)
 123                 return false;
 124
 125         return true;
 126 }
 127
 128 boolean pcap_get_next_record_header(rdpPcap* pcap, pcap_record* record)
 129 {
 130         if (pcap_has_next_record(pcap) != true)
 131                 return false;
 132
 133         pcap_read_record_header(pcap, &record->header);
 134         record->length = record->header.incl_len;
 135         record->data = xmalloc(record->length);
 136
 137         return true;
 138 }
 139
 140 boolean pcap_get_next_record_content(rdpPcap* pcap, pcap_record* record)
 141 {
 142         fread(record->data, record->length, 1, pcap->fp);
 143         return true;
 144 }
 145
 146 boolean pcap_get_next_record(rdpPcap* pcap, pcap_record* record)
 147 {
 148         if (pcap_has_next_record(pcap) != true)
 149                 return false;
 150
 151         pcap_read_record(pcap, record);
 152
 153         return true;
 154 }
 155
 156 rdpPcap* pcap_open(char* name, boolean write)
 157 {
 158         rdpPcap* pcap;
 159
 160         FILE *pcap_fp = fopen(name, write ? "w+" : "r");
 161         if (pcap_fp == NULL)
 162         {
 163                 perror("opening pcap dump");
 164                 return NULL;
 165         }
 166
 167         pcap = (rdpPcap*) xzalloc(sizeof(rdpPcap));
 168
 169         if (pcap != NULL)
 170         {
 171                 pcap->name = name;
 172                 pcap->write = write;
 173                 pcap->record_count = 0;
 174                 pcap->fp = pcap_fp;
 175
 176                 if (write)
 177                 {
 178                         pcap->header.magic_number = 0xA1B2C3D4;
 179                         pcap->header.version_major = 2;
 180                         pcap->header.version_minor = 4;
 181                         pcap->header.thiszone = 0;
 182                         pcap->header.sigfigs = 0;
 183                         pcap->header.snaplen = 0xFFFFFFFF;
 184                         pcap->header.network = 0;
 185                         pcap_write_header(pcap, &pcap->header);
 186                 }
 187                 else
 188                 {
 189                         fseek(pcap->fp, 0, SEEK_END);
 190                         pcap->file_size = (int) ftell(pcap->fp);
 191                         fseek(pcap->fp, 0, SEEK_SET);
 192                         pcap_read_header(pcap, &pcap->header);
 193                 }
 194         }
 195
 196         return pcap;
 197 }
 198
 199 void pcap_flush(rdpPcap* pcap)
 200 {
 201         while (pcap->record != NULL)
 202         {
 203                 pcap_write_record(pcap, pcap->record);
 204                 pcap->record = pcap->record->next;
 205         }
 206
 207         if (pcap->fp != NULL)
 208                 fflush(pcap->fp);
 209 }
 210
 211 void pcap_close(rdpPcap* pcap)
 212 {
 213         pcap_flush(pcap);
 214
 215         if (pcap->fp != NULL)
 216                 fclose(pcap->fp);
 217 }