d726fddade4196971f7a077a45b5155450f803c2
[obnox/wireshark/wip.git] / wiretap / cosine.c
1 /* cosine.c
2  *
3  * $Id: cosine.c,v 1.4 2002/08/16 00:41:39 guy Exp $
4  *
5  * CoSine IPNOS L2 debug output parsing
6  * Copyright (c) 2002 by Motonori Shindo <mshindo@mshindo.net>
7  *
8  * Wiretap Library
9  * Copyright (c) 1998 by Gilbert Ramirez <gram@alumni.rice.edu>
10  * 
11  * This program is free software; you can redistribute it and/or
12  * modify it under the terms of the GNU General Public License
13  * as published by the Free Software Foundation; either version 2
14  * of the License, or (at your option) any later version.
15  * 
16  * This program is distributed in the hope that it will be useful,
17  * but WITHOUT ANY WARRANTY; without even the implied warranty of
18  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
19  * GNU General Public License for more details.
20  * 
21  * You should have received a copy of the GNU General Public License
22  * along with this program; if not, write to the Free Software
23  * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
24  */
25
26 #ifdef HAVE_CONFIG_H
27 #include "config.h"
28 #endif
29 #include "wtap-int.h"
30 #include "buffer.h"
31 #include "cosine.h"
32 #include "file_wrappers.h"
33
34 #include <stdio.h>
35 #include <stdlib.h>
36 #include <string.h>
37 #include <ctype.h>
38
39 /*
40
41   IPNOS: CONFIG VPN(100) VR(1.1.1.1)# diags 
42   ipnos diags: Control (1/0) :: layer-2 ? 
43   Registered commands for area "layer-2" 
44       apply-pkt-log-profile  Configure packet logging on an interface 
45       create-pkt-log-profile  Set packet-log-profile to be used for packet logging (see layer-2 pkt-log) 
46       detail                Get Layer 2 low-level details 
47
48   ipnos diags: Control (1/0) :: layer-2 create ? 
49       create-pkt-log-profile  <pkt-log-profile-id ctl-tx-trace-length ctl-rx-trace-length data-tx-trace-length data-rx-trace-length pe-logging-or-control-blade>
50
51   ipnos diags: Control (1/0) :: layer-2 create 1 32 32 0 0 0 
52   ipnos diags: Control (1/0) :: layer-2 create 2 32 32 100 100 0 
53   ipnos diags: Control (1/0) :: layer-2 apply ?              
54       apply-pkt-log-profile  <slot port channel subif pkt-log-profile-id> 
55
56   ipnos diags: Control (1/0) :: layer-2 apply 3 0x0701 100 0 1 
57   Successfully applied packet-log-profile on LI 
58
59   -- Note that only the control packets are logged because the data packet size parameters are 0 in profile 1 
60   IPNOS: CONFIG VPN(200) VR(3.3.3.3)# ping 20.20.20.43 
61   vpn 200 : [max tries 4, timeout 5 seconds, data length 64 bytes, ttl 255] 
62   ping #1 ok, RTT 0.000 seconds 
63   ping #2 ok, RTT 0.000 seconds 
64   ping #3 ok, RTT 0.000 seconds 
65   ping #4 ok, RTT 0.000 seconds 
66   [finished] 
67
68   IPNOS: CONFIG VPN(200) VR(3.3.3.3)# 2000-2-1,18:19:46.8:  l2-tx (PPP:3/7/1:100), Length:16, Pro:0, Off:0, Pri:0, RM:0, Err:0 [0x4000, 0x0]
69
70     
71   2000-2-1,18:19:46.8:  l2-rx (PPP:3/7/1:100), Length:16, Pro:0, Off:0, Pri:0, RM:0, Err:0 [0x4001, 0x30000] 
72     
73   2000-2-1,18:19:46.8:  l2-tx (PPP:3/7/1:100), Length:16, Pro:0, Off:0, Pri:0, RM:0, Err:0 [0x4000, 0x0] 
74     
75   2000-2-1,18:19:46.8:  l2-rx (PPP:3/7/1:100), Length:16, Pro:0, Off:0, Pri:0, RM:0, Err:0 [0x4001, 0x8030000] 
76
77   ipnos diags: Control (1/0) :: layer-2 apply 3 0x0701 100 0 0 
78   Successfully applied packet-log-profile on LI 
79   ipnos diags: Control (1/0) :: layer-2 apply 3 0x0701 100 0 2 
80   Successfully applied packet-log-profile on LI 
81
82   -- Note that both control and data packets are logged because the data packet size parameter is 100 in profile 2 
83      Please ignore the event-log messages getting mixed up with the ping command
84   ping 20.20.20.43 cou2000-2-1,18:20:17.0:  l2-tx (PPP:3/7/1:100), Length:16, Pro:0, Off:0, Pri:0, RM:0, Err:0 [0x4000, 0x0]
85
86           00 D0 D8 D2 FF 03 C0 21  09 29 00 08 6B 60 84 AA 
87     
88   2000-2-1,18:20:17.0:  l2-rx (PPP:3/7/1:100), Length:16, Pro:0, Off:0, Pri:0, RM:0, Err:0 [0x4001, 0x30000] 
89           00 D0 D8 D2 FF 03 C0 21  09 29 00 08 6D FE FA AA 
90     
91   2000-2-1,18:20:17.0:  l2-tx (PPP:3/7/1:100), Length:16, Pro:0, Off:0, Pri:0, RM:0, Err:0 [0x4000, 0x0] 
92           00 D0 D8 D2 FF 03 C0 21  0A 29 00 08 6B 60 84 AA 
93     
94   2000-2-1,18:20:17.0:  l2-rx (PPP:3/7/1:100), Length:16, Pro:0, Off:0, Pri:0, RM:0, Err:0 [0x4001, 0x8030000] 
95           00 D0 D8 D2 FF 03 C0 21  0A 29 00 08 6D FE FA AA 
96     
97   nt 1 length 500 
98   vpn 200 : [max tries 1, timeout 5 seconds, data length 500 bytes, ttl 255] 
99   2000-2-1,18:20:24.1:  l2-tx (PPP:3/7/1:100), Length:536, Pro:1, Off:8, Pri:7, RM:0, Err:0 [0x4070, 0x801] 
100           00 D0 D8 D2 FF 03 00 21  45 00 02 10 00 27 00 00 
101           FF 01 69 51 14 14 14 22  14 14 14 2B 08 00 AD B8 
102           00 03 00 01 10 11 12 13  14 15 16 17 18 19 1A 1B 
103           1C 1D 1E 1F 20 21 22 23  24 25 26 27 28 29 2A 2B 
104           2C 2D 2E 2F 30 31 32 33  34 35 36 37 38 39 3A 3B 
105           3C 3D 3E 3F 40 41 42 43  44 45 46 47 48 49 4A 4B 
106           4C 4D 4E 4F 
107     
108   ping #1 ok, RTT 0.010 seconds 
109   2000-2-1,18:20:24.1:  l2-rx (PPP:3/7/1:100), Length:536, Pro:1, Off:8, Pri:7, RM:0, Err:0 [0x4071, 0x30801] 
110           00 D0 D8 D2 FF 03 00 21  45 00 02 10 00 23 00 00 
111           FF 01 69 55 14 14 14 2B  14 14 14 22 00 00 B5 B8 
112           00 03 00 01 10 11 12 13  14 15 16 17 18 19 1A 1B 
113           1C 1D 1E 1F 20 21 22 23  24 25 26 27 28 29 2A 2B 
114           2C 2D 2E 2F 30 31 32 33  34 35 36 37 38 39 3A 3B 
115           3C 3D 3E 3F 40 41 42 43  44 45 46 47 48 49 4A 4B 
116           4C 4D 4E 4F 
117     
118   [finished] 
119
120   IPNOS: CONFIG VPN(200) VR(3.3.3.3)# 2000-2-1,18:20:27.0:  l2-tx (PPP:3/7/1:100), Length:16, Pro:0, Off:0, Pri:0, RM:0, Err:0 [0x4000, 0x0]
121
122           00 D0 D8 D2 FF 03 C0 21  09 2A 00 08 6B 60 84 AA 
123     
124   2000-2-1,18:20:27.0:  l2-rx (PPP:3/7/1:100), Length:16, Pro:0, Off:0, Pri:0, RM:0, Err:0 [0x4001, 0x30000] 
125           00 D0 D8 D2 FF 03 C0 21  09 2A 00 08 6D FE FA AA 
126     
127   2000-2-1,18:20:27.0:  l2-tx (PPP:3/7/1:100), Length:16, Pro:0, Off:0, Pri:0, RM:0, Err:0 [0x4000, 0x0] 
128           00 D0 D8 D2 FF 03 C0 21  0A 2A 00 08 6B 60 84 AA 
129     
130   2000-2-1,18:20:27.0:  l2-rx (PPP:3/7/1:100), Length:16, Pro:0, Off:0, Pri:0, RM:0, Err:0 [0x4001, 0x30000] 
131           00 D0 D8 D2 FF 03 C0 21  0A 2A 00 08 6D FE FA AA 
132     
133
134   ipnos diags: Control (1/0) :: layer-2 apply 3 0x0701 100 0 0 
135   Successfully applied packet-log-profile on LI 
136   ipnos diags: Control (1/0) :: 
137
138  */
139
140 /* XXX TODO:
141
142   o Handle a case where an empty line doesn't exists as a delimiter of
143     each packet. If the output is sent to a control blade and
144     displayed as an event log, there's always an empty line between
145     each packet output, but it may not be true when it is an PE
146     output.
147
148   o Some telnet client on Windows may put in a line break at 80
149     columns when it save the session to a text file ("CRT" is such an
150     example). I don't think it's a good idea for the telnet client to
151     do so, but CRT is widely used in Windows community, I should
152     take care of that in the future.
153
154 */
155
156 /* Magic text to check for CoSine L2 debug output */
157 #define COSINE_HDR_MAGIC_STR1   "l2-tx"
158 #define COSINE_HDR_MAGIC_STR2   "l2-rx"
159
160 /* Magic text for start of packet */
161 #define COSINE_REC_MAGIC_STR1   COSINE_HDR_MAGIC_STR1   
162 #define COSINE_REC_MAGIC_STR2   COSINE_HDR_MAGIC_STR2
163
164 #define COSINE_HEADER_LINES_TO_CHECK    200
165 #define COSINE_LINE_LENGTH              240     
166
167 #define COSINE_MAX_PACKET_LEN   65536
168
169 static gboolean empty_line(const guchar *line);
170 static long cosine_seek_next_packet(wtap *wth, int *err, char *hdr);
171 static gboolean cosine_check_file_type(wtap *wth, int *err);
172 static gboolean cosine_read(wtap *wth, int *err, long *data_offset);
173 static gboolean cosine_seek_read(wtap *wth, long seek_off,
174         union wtap_pseudo_header *pseudo_header, guint8 *pd, 
175         int len, int *err);
176 static int parse_cosine_rec_hdr(wtap *wth, const char *line, 
177         union wtap_pseudo_header *pseudo_header, int *err);
178 static int parse_cosine_hex_dump(FILE_T fh, int pkt_len, guint8* buf,
179         int *err);
180 static int parse_single_hex_dump_line(char* rec, guint8 *buf,
181         guint byte_offset);
182
183 /* Returns TRUE if the line appears to be an empty line. Otherwise it 
184    returns FALSE. */
185 static gboolean empty_line(const guchar *line)
186 {
187         while (*line) {
188                 if (isspace(*line)) {
189                         line++;
190                         continue;
191                 } else {
192                         break;
193                 }
194         }
195         if (*line == '\0')
196                 return TRUE;
197         else 
198                 return FALSE;
199 }
200
201 /* Seeks to the beginning of the next packet, and returns the
202    byte offset. Copy the header line to hdr. Returns -1 on failure, 
203    and sets "*err" to the error and set hdr as NULL. */
204 static long cosine_seek_next_packet(wtap *wth, int *err, char *hdr)
205 {
206         long cur_off;
207         char buf[COSINE_LINE_LENGTH];
208
209         while (1) {
210                 cur_off = file_tell(wth->fh);
211                 if (cur_off == -1) {
212                         /* Error */
213                         *err = file_error(wth->fh);
214                         hdr = NULL;
215                         return -1;
216                 }
217                 if (file_gets(buf, sizeof(buf), wth->fh) != NULL) {
218                         if (strstr(buf, COSINE_REC_MAGIC_STR1) || 
219                             strstr(buf, COSINE_REC_MAGIC_STR2)) {
220                                 strncpy(hdr, buf, COSINE_LINE_LENGTH-1);
221                                 hdr[COSINE_LINE_LENGTH-1] = '\0';
222                                 return cur_off;
223                         }
224                 } else {
225                         if (file_eof(wth->fh)) {
226                                 /* We got an EOF. */
227                                 *err = 0;
228                         } else {
229                                 /* We (presumably) got an error (there's no 
230                                    equivalent to "ferror()" in zlib, alas, 
231                                    so we don't have a wrapper to check for 
232                                    an error). */
233                                 *err = file_error(wth->fh);
234                         }
235                         break;
236                 }
237         }
238         hdr = NULL;
239         return -1;
240 }
241
242 /* Look through the first part of a file to see if this is
243  * a CoSine L2 debug output. 
244  *
245  * Returns TRUE if it is, FALSE if it isn't or if we get an I/O error;
246  * if we get an I/O error, "*err" will be set to a non-zero value.
247  */
248 static gboolean cosine_check_file_type(wtap *wth, int *err)
249 {
250         char    buf[COSINE_LINE_LENGTH];
251         guint   reclen, line;
252
253         buf[COSINE_LINE_LENGTH-1] = '\0';
254
255         for (line = 0; line < COSINE_HEADER_LINES_TO_CHECK; line++) {
256                 if (file_gets(buf, COSINE_LINE_LENGTH, wth->fh) != NULL) {
257
258                         reclen = strlen(buf);
259                         if (reclen < strlen(COSINE_HDR_MAGIC_STR1) ||
260                                 reclen < strlen(COSINE_HDR_MAGIC_STR2)) {
261                                 continue;
262                         }
263
264                         if (strstr(buf, COSINE_HDR_MAGIC_STR1) ||
265                             strstr(buf, COSINE_HDR_MAGIC_STR2)) {
266                                 return TRUE;
267                         }
268                 } else {
269                         /* EOF or error. */
270                         if (file_eof(wth->fh))
271                                 *err = 0;
272                         else
273                                 *err = file_error(wth->fh);
274                         return FALSE;
275                 }
276         }
277         *err = 0;
278         return FALSE;
279 }
280
281
282 int cosine_open(wtap *wth, int *err)
283 {
284         /* Look for CoSine header */
285         if (!cosine_check_file_type(wth, err)) {
286                 if (*err == 0)
287                         return 0;
288                 else
289                         return -1;
290         }
291
292         if (file_seek(wth->fh, 0L, SEEK_SET, err) == -1) {      /* rewind */
293                 *err = file_error(wth->fh);
294                 return -1;
295         }
296
297         wth->data_offset = 0;
298         wth->file_encap = WTAP_ENCAP_COSINE;
299         wth->file_type = WTAP_FILE_COSINE;
300         wth->snapshot_length = 0; /* not known */
301         wth->subtype_read = cosine_read;
302         wth->subtype_seek_read = cosine_seek_read;
303
304         return 1;
305 }
306
307 /* Find the next packet and parse it; called from wtap_loop(). */
308 static gboolean cosine_read(wtap *wth, int *err, long *data_offset)
309 {
310         long    offset;
311         guint8  *buf;
312         int     pkt_len, caplen;
313         char    line[COSINE_LINE_LENGTH];
314
315         /* Find the next packet */
316         offset = cosine_seek_next_packet(wth, err, line);
317         if (offset < 0)
318                 return FALSE;
319
320         /* Parse the header */
321         pkt_len = parse_cosine_rec_hdr(wth, line, &wth->pseudo_header, err);
322         if (pkt_len == -1)
323                 return FALSE;
324
325         /* Make sure we have enough room for the packet */
326         buffer_assure_space(wth->frame_buffer, COSINE_MAX_PACKET_LEN);
327         buf = buffer_start_ptr(wth->frame_buffer);
328
329         /* Convert the ASCII hex dump to binary data */
330         if ((caplen = parse_cosine_hex_dump(wth->fh, pkt_len, buf, err)) == -1)
331                 return FALSE;
332
333         wth->data_offset = offset;
334         wth->phdr.caplen = caplen;
335         *data_offset = offset;
336         return TRUE;
337 }
338
339 /* Used to read packets in random-access fashion */
340 static gboolean
341 cosine_seek_read (wtap *wth, long seek_off,
342         union wtap_pseudo_header *pseudo_header, guint8 *pd, int len, int *err)
343 {
344         char    line[COSINE_LINE_LENGTH];
345
346         if (file_seek(wth->random_fh, seek_off, SEEK_SET, err) == -1) {
347                 *err = file_error(wth->random_fh);
348                 return FALSE;
349         }
350
351         if (file_gets(line, COSINE_LINE_LENGTH, wth->random_fh) == NULL) {
352                 *err = file_error(wth->random_fh);
353                 if (*err == 0) {
354                         *err = WTAP_ERR_SHORT_READ;
355                 }
356                 return FALSE;
357         }
358
359         if (parse_cosine_rec_hdr(NULL, line, pseudo_header, err) == -1) { 
360                 *err = file_error(wth->random_fh);
361                 if (*err == 0) {
362                         *err = WTAP_ERR_BAD_RECORD;
363                 }
364                 return FALSE;
365         }
366
367         return parse_cosine_hex_dump(wth->random_fh, len, pd, err);
368 }
369
370 /* Parses a packet record header. There are two possible formats:
371     1) output to a control blade with date and time
372         2002-5-10,20:1:31.4:  l2-tx (FR:3/7/1:1), Length:18, Pro:0, Off:0, Pri:0, RM:0, Err:0 [0x4000, 0x0]
373     2) output to PE without date and time
374         l2-tx (FR:3/7/1:1), Length:18, Pro:0, Off:0, Pri:0, RM:0, Err:0 [0x4000, 0x0] */
375 static int
376 parse_cosine_rec_hdr(wtap *wth, const char *line, union wtap_pseudo_header *pseudo_header, int *err)
377 {
378         int     num_items_scanned;
379         int     yy, mm, dd, hr, min, sec, csec, pkt_len;
380         int     pro, off, pri, rm, error, code1, code2;
381         char    if_name[COSINE_MAX_IF_NAME_LEN], direction[6];
382         struct  tm tm;
383
384         if (sscanf(line, "%d-%d-%d,%d:%d:%d.%d:", 
385                    &yy, &mm, &dd, &hr, &min, &sec, &csec) == 7) {
386                 /* appears to be output to a control blade */
387                 num_items_scanned = sscanf(line, 
388                    "%d-%d-%d,%d:%d:%d.%d: %5s (%127[A-Za-z0-9/:]), Length:%d, Pro:%d, Off:%d, Pri:%d, RM:%d, Err:%d [%x, %x]",
389                         &yy, &mm, &dd, &hr, &min, &sec, &csec,
390                                    direction, if_name, &pkt_len, 
391                                    &pro, &off, &pri, &rm, &error, 
392                                    &code1, &code2);
393
394                 if (num_items_scanned != 17) {
395                         *err = WTAP_ERR_BAD_RECORD;
396                         return -1;
397                 }
398         } else {
399                 /* appears to be output to PE */
400                 num_items_scanned = sscanf(line, 
401                    "%5s (%127[A-Za-z0-9/:]), Length:%d, Pro:%d, Off:%d, Pri:%d, RM:%d, Err:%d [%x, %x]",
402                                    direction, if_name, &pkt_len, 
403                                    &pro, &off, &pri, &rm, &error, 
404                                    &code1, &code2);
405
406                 if (num_items_scanned != 10) {
407                         *err = WTAP_ERR_BAD_RECORD;
408                         return -1;
409                 }
410                 yy = mm = dd = hr = min = sec = csec = 0;
411         }
412
413         if (wth) { 
414                 tm.tm_year = yy - 1900;
415                 tm.tm_mon = mm - 1;
416                 tm.tm_mday = dd;
417                 tm.tm_hour = hr;
418                 tm.tm_min = min;
419                 tm.tm_sec = sec;
420                 tm.tm_isdst = -1;
421                 wth->phdr.ts.tv_sec = mktime(&tm);
422                 wth->phdr.ts.tv_usec = csec * 10000;
423                 wth->phdr.len = pkt_len;
424                 wth->phdr.pkt_encap = WTAP_ENCAP_COSINE;
425         } 
426         /* XXX need to handle other encapsulations like Cisco HDLC, 
427            Frame Relay and ATM */
428         if (strncmp(if_name, "TEST:", 5) == 0) {
429                 pseudo_header->cosine.encap = COSINE_ENCAP_TEST;
430         } else if (strncmp(if_name, "PPoATM:", 7) == 0) {
431                 pseudo_header->cosine.encap = COSINE_ENCAP_PPoATM;
432         } else if (strncmp(if_name, "PPoFR:", 6) == 0) {
433                 pseudo_header->cosine.encap = COSINE_ENCAP_PPoFR;
434         } else if (strncmp(if_name, "ATM:", 4) == 0) {
435                 pseudo_header->cosine.encap = COSINE_ENCAP_ATM;
436         } else if (strncmp(if_name, "FR:", 3) == 0) {
437                 pseudo_header->cosine.encap = COSINE_ENCAP_FR;
438         } else if (strncmp(if_name, "HDLC:", 5) == 0) {
439                 pseudo_header->cosine.encap = COSINE_ENCAP_HDLC;
440         } else if (strncmp(if_name, "PPP:", 4) == 0) {
441                 pseudo_header->cosine.encap = COSINE_ENCAP_PPP;
442         } else if (strncmp(if_name, "ETH:", 4) == 0) {
443                 pseudo_header->cosine.encap = COSINE_ENCAP_ETH;
444         } else {
445                 pseudo_header->cosine.encap = COSINE_ENCAP_UNKNOWN;
446         }
447         if (strncmp(direction, "l2-tx", 5) == 0) {
448                 pseudo_header->cosine.direction = COSINE_DIR_TX;
449         } else if (strncmp(direction, "l2-rx", 5) == 0) {
450                 pseudo_header->cosine.direction = COSINE_DIR_RX;
451         } 
452         strncpy(pseudo_header->cosine.if_name, if_name, 
453                 COSINE_MAX_IF_NAME_LEN - 1);
454         pseudo_header->cosine.pro = pro;
455         pseudo_header->cosine.off = off;
456         pseudo_header->cosine.pri = pri;
457         pseudo_header->cosine.rm = rm;
458         pseudo_header->cosine.err = error;
459
460         return pkt_len;
461 }
462
463 /* Converts ASCII hex dump to binary data. Returns the capture length.
464    If any error is encountered, -1 is returned. */
465 static int
466 parse_cosine_hex_dump(FILE_T fh, int pkt_len, guint8* buf, int *err)
467 {
468         char    line[COSINE_LINE_LENGTH];
469         int     i, hex_lines, n, caplen = 0;
470         
471         /* Calculate the number of hex dump lines, each
472          * containing 16 bytes of data */
473         hex_lines = pkt_len / 16 + ((pkt_len % 16) ? 1 : 0);
474
475         for (i = 0; i < hex_lines; i++) {
476                 if (file_gets(line, COSINE_LINE_LENGTH, fh) == NULL) {
477                         *err = file_error(fh);
478                         if (*err == 0) {
479                                 *err = WTAP_ERR_SHORT_READ;
480                         }
481                         return -1;
482                 }
483                 if (empty_line(line)) {
484                         break;
485                 }
486                 if ((n = parse_single_hex_dump_line(line, buf, i*16)) == -1) {
487                         *err = WTAP_ERR_BAD_RECORD;
488                         return -1;
489                 }
490                 caplen += n;
491         }
492         return caplen;
493 }
494
495
496 /* Take a string representing one line from a hex dump and converts
497  * the text to binary data. We place the bytes in the buffer at the
498  * specified offset.
499  *
500  * Returns number of bytes successfully read, -1 if bad.  */
501 static int
502 parse_single_hex_dump_line(char* rec, guint8 *buf, guint byte_offset) 
503 {
504         int num_items_scanned, i;
505         unsigned int bytes[16];
506
507         num_items_scanned = sscanf(rec, "%02x %02x %02x %02x %02x %02x %02x %02x %02x %02x %02x %02x %02x %02x %02x %02x", 
508                                &bytes[0], &bytes[1], &bytes[2], &bytes[3], 
509                                &bytes[4], &bytes[5], &bytes[6], &bytes[7],
510                                &bytes[8], &bytes[9], &bytes[10], &bytes[11], 
511                                &bytes[12], &bytes[13], &bytes[14], &bytes[15]);
512         if (num_items_scanned == 0)
513                 return -1;
514
515         if (num_items_scanned > 16) 
516                 num_items_scanned = 16;
517
518         for (i=0; i<num_items_scanned; i++) {
519                 buf[byte_offset + i] = (guint8)bytes[i];
520         }
521
522         return num_items_scanned;
523 }