test-suite-pull-tools-directly-in-20020114
[openafs.git] / src / tests / primitive.c
1 /*
2  * CMUCS AFStools
3  * dumpscan - routines for scanning and manipulating AFS volume dumps
4  *
5  * Copyright (c) 1998 Carnegie Mellon University
6  * All Rights Reserved.
7  * 
8  * Permission to use, copy, modify and distribute this software and its
9  * documentation is hereby granted, provided that both the copyright
10  * notice and this permission notice appear in all copies of the
11  * software, derivative works or modified versions, and any portions
12  * thereof, and that both notices appear in supporting documentation.
13  *
14  * CARNEGIE MELLON ALLOWS FREE USE OF THIS SOFTWARE IN ITS "AS IS"
15  * CONDITION.  CARNEGIE MELLON DISCLAIMS ANY LIABILITY OF ANY KIND FOR
16  * ANY DAMAGES WHATSOEVER RESULTING FROM THE USE OF THIS SOFTWARE.
17  *
18  * Carnegie Mellon requests users of this software to return to
19  *
20  *  Software Distribution Coordinator  or  Software_Distribution@CS.CMU.EDU
21  *  School of Computer Science
22  *  Carnegie Mellon University
23  *  Pittsburgh PA 15213-3890
24  *
25  * any improvements or extensions that they make and grant Carnegie Mellon
26  * the rights to redistribute these changes.
27  */
28
29 /* primitive.c - Routines for reading and writing low-level things */
30
31 #include <sys/types.h>
32 #include <netinet/in.h>
33 #include <errno.h>
34 #include <stdlib.h>
35 #include <string.h>
36
37 #include "dumpscan.h"
38
39 #define BUFSIZE 256
40
41
42 afs_uint32 ReadByte(XFILE *X, unsigned char *val)
43 {
44   return xfread(X, val, 1);
45 }
46
47 afs_uint32 ReadInt16(XFILE *X, afs_uint16 *val)
48 {
49   afs_uint32 r;
50
51   if (r = xfread(X, val, 2)) return r;
52   *val = ntohs(*val);
53   return 0;
54 }
55
56 afs_uint32 ReadInt32(XFILE *X, afs_uint32 *val)
57 {
58   afs_uint32 r;
59
60   if (r = xfread(X, val, 4)) return r;
61   *val = ntohl(*val);
62   return 0;
63 }
64
65 /* Read in a NUL-terminated string.  This method is kind of messy, but
66  * has the advantage that it reads the data stream only once, doesn't
67  * read anything extra, and never has to seek on the data stream.
68  */
69 afs_uint32 ReadString(XFILE *X, unsigned char **val)
70 {
71   static unsigned char buf[BUFSIZE];
72   unsigned char *result = 0;
73   afs_uint32 r;
74   int i, l = 0;
75
76   *val = 0;
77   for (;;) {
78     for (i = 0; i < BUFSIZE; i++) {
79       r = ReadByte(X, buf + i);
80       if (r) {
81         if (result) free(result);
82         return r;
83       }
84       if (!buf[i]) break;
85     }
86     /* iff we found a null, i < BUFSIZE and buf[i] holds the NUL */
87     if (result) result = (unsigned char *)realloc(result, l + i + 1);
88     else result = (unsigned char *)malloc(i + 1);
89     if (!result) return ENOMEM;
90     memcpy(result + l, buf, i);
91     result[l+i] = 0;
92     l += i;
93     if (i < BUFSIZE) break;
94   }
95   *val = result;
96   return 0;
97 }
98
99
100 afs_uint32 WriteByte(XFILE *X, unsigned char val)
101 {
102   return xfwrite(X, &val, 1);
103 }
104
105 afs_uint32 WriteInt16(XFILE *X, afs_uint16 val)
106 {
107   val = htons(val);
108   return xfwrite(X, &val, 2);
109 }
110
111 afs_uint32 WriteInt32(XFILE *X, afs_uint32 val)
112 {
113   val = htonl(val);
114   return xfwrite(X, &val, 4);
115 }
116
117 afs_uint32 WriteString(XFILE *X, unsigned char *str)
118 {
119   int len = strlen((char *)str) + 1;
120   return xfwrite(X, str, len);
121 }
122
123 afs_uint32 WriteTagByte(XFILE *X, unsigned char tag, unsigned char val)
124 {
125   char buffer[2];
126   buffer[0] = tag;
127   buffer[1] = val;
128   return xfwrite(X, buffer, 2);
129 }
130
131 afs_uint32 WriteTagInt16(XFILE *X, unsigned char tag, afs_uint16 val)
132 {
133   char buffer[3];
134   buffer[0] = tag;
135   buffer[1] = (val & 0xff00) >> 8;
136   buffer[2] = val & 0xff;
137   return xfwrite(X, buffer, 3);
138 }
139
140 afs_uint32 WriteTagInt32(XFILE *X, unsigned char tag, afs_uint32 val)
141 {
142   char buffer[5];
143   buffer[0] = tag;
144   buffer[1] = (val & 0xff000000) >> 24;
145   buffer[2] = (val & 0xff0000) >> 16;
146   buffer[3] = (val & 0xff00) >> 8;
147   buffer[4] = val & 0xff;
148   return xfwrite(X, buffer, 5);
149 }
150
151 afs_uint32 WriteTagInt32Pair(XFILE *X, unsigned char tag,
152                              afs_uint32 val1, afs_uint32 val2)
153 {
154   char buffer[9];
155   buffer[0] = tag;
156   buffer[1] = (val1 & 0xff000000) >> 24;
157   buffer[2] = (val1 & 0xff0000) >> 16;
158   buffer[3] = (val1 & 0xff00) >> 8;
159   buffer[4] = val1 & 0xff;
160   buffer[5] = (val2 & 0xff000000) >> 24;
161   buffer[6] = (val2 & 0xff0000) >> 16;
162   buffer[7] = (val2 & 0xff00) >> 8;
163   buffer[8] = val2 & 0xff;
164   return xfwrite(X, buffer, 9);
165 }