Fix up prototype of strtoul() to match POSIX.
[people/xl0/gpxe.git] / src / core / misc.c
1 /**************************************************************************
2 MISC Support Routines
3 **************************************************************************/
4
5 #include "etherboot.h"
6 #include "console.h"
7
8 /**************************************************************************
9 IPCHKSUM - Checksum IP Header
10 **************************************************************************/
11 uint16_t ipchksum(const void *data, unsigned long length)
12 {
13         unsigned long sum;
14         unsigned long i;
15         const uint8_t *ptr;
16
17         /* In the most straight forward way possible,
18          * compute an ip style checksum.
19          */
20         sum = 0;
21         ptr = data;
22         for(i = 0; i < length; i++) {
23                 unsigned long value;
24                 value = ptr[i];
25                 if (i & 1) {
26                         value <<= 8;
27                 }
28                 /* Add the new value */
29                 sum += value;
30                 /* Wrap around the carry */
31                 if (sum > 0xFFFF) {
32                         sum = (sum + (sum >> 16)) & 0xFFFF;
33                 }
34         }
35         return (~cpu_to_le16(sum)) & 0xFFFF;
36 }
37
38 uint16_t add_ipchksums(unsigned long offset, uint16_t sum, uint16_t new)
39 {
40         unsigned long checksum;
41         sum = ~sum & 0xFFFF;
42         new = ~new & 0xFFFF;
43         if (offset & 1) {
44                 /* byte swap the sum if it came from an odd offset 
45                  * since the computation is endian independant this
46                  * works.
47                  */
48                 new = bswap_16(new);
49         }
50         checksum = sum + new;
51         if (checksum > 0xFFFF) {
52                 checksum -= 0xFFFF;
53         }
54         return (~checksum) & 0xFFFF;
55 }
56
57
58
59 /**************************************************************************
60 RANDOM - compute a random number between 0 and 2147483647L or 2147483562?
61 **************************************************************************/
62 int32_t random(void)
63 {
64         static int32_t seed = 0;
65         int32_t q;
66         if (!seed) /* Initialize linear congruential generator */
67                 seed = currticks() + *(int32_t *)&arptable[ARP_CLIENT].node
68                        + ((int16_t *)arptable[ARP_CLIENT].node)[2];
69         /* simplified version of the LCG given in Bruce Schneier's
70            "Applied Cryptography" */
71         q = seed/53668;
72         if ((seed = 40014*(seed-53668*q) - 12211*q) < 0) seed += 2147483563L;
73         return seed;
74 }
75
76 /**************************************************************************
77 POLL INTERRUPTIONS
78 **************************************************************************/
79 void poll_interruptions(void)
80 {
81         int ch;
82         if ( ! as_main_program ) return;
83         /* If an interruption has occured restart etherboot */
84         if (iskey() && (ch = getchar(), (ch == K_ESC) || (ch == K_EOF) || (ch == K_INTR))) {
85                 int state = (ch != K_INTR)? -1 : -3;
86                 longjmp(restart_etherboot, state);
87         }
88 }
89
90 /**************************************************************************
91 SLEEP
92 **************************************************************************/
93 void sleep(int secs)
94 {
95         unsigned long tmo;
96
97         for (tmo = currticks()+secs*TICKS_PER_SEC; currticks() < tmo; ) {
98                 poll_interruptions();
99         }
100 }
101
102 /**************************************************************************
103 INTERRUPTIBLE SLEEP
104 **************************************************************************/
105 void interruptible_sleep(int secs)
106 {
107         printf("<sleep>\n");
108         return sleep(secs);
109 }
110
111 /**************************************************************************
112 TWIDDLE
113 **************************************************************************/
114 void twiddle(void)
115 {
116 #ifdef BAR_PROGRESS
117         static int count=0;
118         static const char tiddles[]="-\\|/";
119         static unsigned long lastticks = 0;
120         unsigned long ticks;
121 #endif
122         if ( ! as_main_program ) return;
123 #ifdef  BAR_PROGRESS
124         /* Limit the maximum rate at which characters are printed */
125         ticks = currticks();
126         if ((lastticks + (TICKS_PER_SEC/18)) > ticks)
127                 return;
128         lastticks = ticks;
129
130         putchar(tiddles[(count++)&3]);
131         putchar('\b');
132 #else
133         putchar('.');
134 #endif  /* BAR_PROGRESS */
135 }
136
137 /**************************************************************************
138 STRCASECMP (not entirely correct, but this will do for our purposes)
139 **************************************************************************/
140 int strcasecmp(const char *a, const char *b)
141 {
142         while (*a && *b && (*a & ~0x20) == (*b & ~0x20)) {a++; b++; }
143         return((*a & ~0x20) - (*b & ~0x20));
144 }
145
146 /**************************************************************************
147 INET_ATON - Convert an ascii x.x.x.x to binary form
148 **************************************************************************/
149 int inet_aton ( const char *cp, struct in_addr *inp ) {
150         const char *p = cp;
151         const char *digits_start;
152         unsigned long ip = 0;
153         unsigned long val;
154         int j;
155         for(j = 0; j <= 3; j++) {
156                 digits_start = p;
157                 val = strtoul(p, &p, 10);
158                 if ((p == digits_start) || (val > 255)) return 0;
159                 if ( ( j < 3 ) && ( *(p++) != '.' ) ) return 0;
160                 ip = (ip << 8) | val;
161         }
162         if ( *p == '\0' ) {
163                 inp->s_addr = htonl(ip);
164                 return 1;
165         }
166         return 0;
167 }
168
169 unsigned long strtoul(const char *p, char **endp, int base)
170 {
171         unsigned long ret = 0;
172         if (base != 10) return 0;
173         while((*p >= '0') && (*p <= '9')) {
174                 ret = ret*10 + (*p - '0');
175                 p++;
176         }
177         if (endp)
178                 *endp = p;
179         return(ret);
180         
181 }
182
183
184 #if DEBUG_UTILS
185
186 void pause ( void ) {
187         printf ( "\nPress a key" );
188         getchar();
189         printf ( "\r           \r" );
190 }
191
192 void more ( void ) {
193         printf ( "---more---" );
194         getchar();
195         printf ( "\r          \r" );
196 }
197
198 /* Produce a paged hex dump of the specified data and length */
199 void hex_dump ( const char *data, const unsigned int len ) {
200         unsigned int index;
201         for ( index = 0; index < len; index++ ) {
202                 if ( ( index % 16 ) == 0 ) {
203                         printf ( "\n" );
204                 }
205                 if ( ( index % 368 ) == 352 ) {
206                         more();
207                 }
208                 if ( ( index % 16 ) == 0 ) {
209                         printf ( "%X [%X] : %hX :", data + index,
210                                  virt_to_phys ( data + index ), index );
211                 }
212                 printf ( " %hhX", data[index] );
213         }
214         printf ( "\n" );
215 }
216
217 #define GUARD_SYMBOL ( ( 'M' << 24 ) | ( 'I' << 16 ) | ( 'N' << 8 ) | 'E' )
218 /* Fill a region with guard markers.  We use a 4-byte pattern to make
219  * it less likely that check_region will find spurious 1-byte regions
220  * of non-corruption.
221  */
222 void guard_region ( void *region, size_t len ) {
223         uint32_t offset = 0;
224
225         len &= ~0x03;
226         for ( offset = 0; offset < len ; offset += 4 ) {
227                 *((uint32_t *)(region + offset)) = GUARD_SYMBOL;
228         }
229 }
230
231 /* Check a region that has been guarded with guard_region() for
232  * corruption.
233  */
234 int check_region ( void *region, size_t len ) {
235         uint8_t corrupted = 0;
236         uint8_t in_corruption = 0;
237         uint32_t offset = 0;
238         uint32_t test = 0;
239
240         len &= ~0x03;
241         for ( offset = 0; offset < len ; offset += 4 ) {
242                 test = *((uint32_t *)(region + offset)) = GUARD_SYMBOL;
243                 if ( ( in_corruption == 0 ) &&
244                      ( test != GUARD_SYMBOL ) ) {
245                         /* Start of corruption */
246                         if ( corrupted == 0 ) {
247                                 corrupted = 1;
248                                 printf ( "Region %#x-%#x (physical %#x-%#x) "
249                                          "corrupted\n",
250                                          region, region + len,
251                                          virt_to_phys ( region ),
252                                          virt_to_phys ( region + len ) );
253                         }
254                         in_corruption = 1;
255                         printf ( "--- offset %#x ", offset );
256                 } else if ( ( in_corruption != 0 ) &&
257                             ( test == GUARD_SYMBOL ) ) {
258                         /* End of corruption */
259                         in_corruption = 0;
260                         printf ( "to offset %#x", offset );
261                 }
262
263         }
264         if ( in_corruption != 0 ) {
265                 printf ( "to offset %#x (end of region)\n", len-1 );
266         }
267         return corrupted;
268 }
269
270 #endif /* DEBUG_UTILS */
271
272 /*
273  * Local variables:
274  *  c-basic-offset: 8
275  * End:
276  */