lib/databin.c

   1 // SPDX-License-Identifier: GPL-2.0
   2 /*
   3  * Copyright (c) 2000 Silicon Graphics, Inc.
   4  * All Rights Reserved.
   5  */
   6 #include <stdio.h>
   7 #include <sys/param.h>
   8 #include <string.h> /* memset */
   9 #include <stdlib.h> /* rand */
  10 #include "databin.h"
  11
  12 #if UNIT_TEST
  13 #include <malloc.h>
  14 #endif
  15
  16 static char Errmsg[80];
  17
  18 void
  19 databingen (mode, buffer, bsize, offset)
  20 int mode;       /* either a, c, r, o, z or C */
  21 unsigned char *buffer;  /* buffer pointer */
  22 int bsize;      /* size of buffer */
  23 int offset;     /* offset into the file where buffer starts */
  24 {
  25 int ind;
  26
  27         switch (mode)
  28         {
  29         default:
  30         case 'a':       /* alternating bit pattern */
  31                 memset(buffer,0x55,bsize);
  32                 break;
  33
  34         case 'c':       /* checkerboard pattern */
  35                 memset(buffer,0xf0,bsize);
  36                 break;
  37
  38         case 'C':       /* */
  39                 for (ind=0;ind< bsize;ind++) {
  40                     buffer[ind] = ((offset+ind)%8 & 0177);
  41                 }
  42                 break;
  43
  44         case 'o':
  45                 memset(buffer,0xff,bsize);
  46                 break;
  47
  48         case 'z':
  49                 memset(buffer,0x0,bsize);
  50                 break;
  51
  52         case 'r':       /* random */
  53                 for (ind=0;ind< bsize;ind++) {
  54                     buffer[ind] = (rand () & 0177) | 0100;
  55                 }
  56         }
  57 }
  58
  59 /***********************************************************************
  60  *
  61  * return values:
  62  *      >= 0 : error at byte offset into the file, offset+buffer[0-(bsize-1)]
  63  *      < 0  : no error
  64  ***********************************************************************/
  65 int
  66 databinchk(mode, buffer, bsize, offset, errmsg)
  67 int mode;       /* either a, c, r, z, o, or C */
  68 unsigned char *buffer;  /* buffer pointer */
  69 int bsize;      /* size of buffer */
  70 int offset;     /* offset into the file where buffer starts */
  71 char **errmsg;
  72 {
  73         int cnt;
  74         unsigned char *chr;
  75         long expbits;
  76         long actbits;
  77
  78         chr=buffer;
  79
  80         if ( errmsg != NULL ) {
  81             *errmsg = Errmsg;
  82         }
  83
  84         switch (mode)
  85         {
  86         default:
  87         case 'a':       /* alternating bit pattern */
  88                 expbits=0x55;
  89                 break;
  90
  91         case 'c':       /* checkerboard pattern */
  92                 expbits=0xf0;
  93                 break;
  94
  95         case 'C':       /* counting pattern */
  96                 for (cnt=0;cnt< bsize;cnt++) {
  97                     expbits = ((offset+cnt)%8 & 0177);
  98
  99                     if ( buffer[cnt] != expbits ) {
 100                         sprintf(Errmsg,
 101                             "data mismatch at offset %d, exp:%#lo, act:%#o",
 102                             offset+cnt, expbits, buffer[cnt]);
 103                         return offset+cnt;
 104                     }
 105                 }
 106                 sprintf(Errmsg, "all %d bytes match desired pattern", bsize);
 107                 return -1;
 108
 109         case 'o':
 110                 expbits=0xff;
 111                 break;
 112
 113         case 'z':
 114                 expbits=0;
 115                 break;
 116
 117         case 'r':
 118                 return -1;      /* no check can be done for random */
 119         }
 120
 121         for (cnt=0; cnt<bsize; chr++, cnt++) {
 122             actbits = (long)*chr;
 123
 124             if ( actbits != expbits ) {
 125                 sprintf(Errmsg, "data mismatch at offset %d, exp:%#lo, act:%#lo",
 126                     offset+cnt, expbits, actbits);
 127                 return offset+cnt;
 128             }
 129         }
 130
 131         sprintf(Errmsg, "all %d bytes match desired pattern", bsize);
 132         return -1; /* all ok */
 133 }
 134
 135 #if UNIT_TEST
 136
 137 /***********************************************************************
 138  * main for doing unit testing
 139  ***********************************************************************/
 140 int
 141 main(ac, ag)
 142 int ac;
 143 char **ag;
 144 {
 145
 146     int size=1023;
 147     int offset;
 148     int number;
 149     unsigned char *buffer;
 150     int ret;
 151     char *errmsg;
 152
 153     if ((buffer=(unsigned char *)malloc(size)) == NULL ) {
 154         perror("malloc");
 155         exit(2);
 156     }
 157
 158
 159 printf("***** for a ****************************\n");
 160     databingen('a', buffer, size, 0);
 161     printf("databingen('a', buffer, %d, 0)\n", size);
 162
 163     ret=databinchk('a', buffer, size, 0, &errmsg);
 164     printf("databinchk('a', buffer, %d, 0, &errmsg) returned %d: %s\n",
 165         size, ret, errmsg);
 166     if ( ret == -1 )
 167         printf("\tPASS return value of -1 as expected\n");
 168     else
 169         printf("\tFAIL return value %d, expected -1\n", ret);
 170
 171     offset=232400;
 172     ret=databinchk('a', &buffer[1], size-1, offset, &errmsg);
 173     printf("databinchk('a', &buffer[1], %d, %d, &errmsg) returned %d: %s\n",
 174         size, offset, ret, errmsg);
 175     if ( ret == -1 )
 176         printf("\tPASS return value of -1 as expected\n");
 177     else
 178         printf("\tFAIL return value %d, expected -1\n", ret);
 179
 180     buffer[15]= 0x0;
 181     printf("changing char 15 (offset (%d+15) = %d) to 0x0\n", offset, offset+15);
 182     number=offset+15;
 183
 184     ret=databinchk('a', &buffer[1], size-1, offset+1, &errmsg);
 185     printf("databinchk('a', &buffer[1], %d, %d, &errmsg) returned %d: %s\n",
 186         size-1, offset+1, ret, errmsg);
 187     if ( ret == number )
 188         printf("\tPASS return value of %d as expected\n", number);
 189     else
 190         printf("\tFAIL return value %d, expected %d\n", ret, number);
 191
 192
 193
 194 printf("***** for c ****************************\n");
 195     databingen('c', buffer, size, 0);
 196     printf("databingen('c', buffer, %d, 0)\n", size);
 197
 198     ret=databinchk('c', buffer, size, 0, &errmsg);
 199     printf("databinchk('c', buffer, %d, 0, &errmsg) returned %d: %s\n",
 200         size, ret, errmsg);
 201     if ( ret == -1 )
 202         printf("\tPASS return value of -1 as expected\n");
 203     else
 204         printf("\tFAIL return value %d, expected -1\n", ret);
 205
 206     offset=232400;
 207     ret=databinchk('c', &buffer[1], size-1, offset, &errmsg);
 208     printf("databinchk('c', &buffer[1], %d, %d, &errmsg) returned %d: %s\n",
 209         size, offset, ret, errmsg);
 210     if ( ret == -1 )
 211         printf("\tPASS return value of -1 as expected\n");
 212     else
 213         printf("\tFAIL return value %d, expected -1\n", ret);
 214
 215     buffer[15]= 0x0;
 216     printf("changing char 15 (offset (%d+15) = %d) to 0x0\n", offset, offset+15);
 217     number=offset+15;
 218
 219     ret=databinchk('c', &buffer[1], size-1, offset+1, &errmsg);
 220     printf("databinchk('c', &buffer[1], %d, %d, &errmsg) returned %d: %s\n",
 221         size-1, offset+1, ret, errmsg);
 222     if ( ret == number )
 223         printf("\tPASS return value of %d as expected\n", number);
 224     else
 225         printf("\tFAIL return value %d, expected %d\n", ret, number);
 226
 227 printf("***** for C ****************************\n");
 228
 229     databingen('C', buffer, size, 0);
 230     printf("databingen('C', buffer, %d, 0)\n", size);
 231
 232     ret=databinchk('C', buffer, size, 0, &errmsg);
 233     printf("databinchk('C', buffer, %d, 0, &errmsg) returned %d: %s\n",
 234         size, ret, errmsg);
 235     if ( ret == -1 )
 236         printf("\tPASS return value of -1 as expected\n");
 237     else
 238         printf("\tFAIL return value %d, expected -1\n", ret);
 239
 240     offset=18;
 241     ret=databinchk('C', &buffer[18], size-18, 18, &errmsg);
 242     printf("databinchk('C', &buffer[18], %d, 18, &errmsg) returned %d: %s\n",
 243         size-18, ret, errmsg);
 244     if ( ret == -1 )
 245         printf("\tPASS return value of -1 as expected\n");
 246     else
 247         printf("\tFAIL return value %d, expected -1\n", ret);
 248
 249     buffer[20]= 0x0;
 250     buffer[21]= 0x0;
 251     printf("changing char 20 and 21 to 0x0 (offset %d and %d)\n", 20,
 252         21);
 253
 254     ret=databinchk('C', &buffer[18], size-18, 18, &errmsg);
 255     printf("databinchk('C', &buffer[18], %d, 18, &errmsg) returned %d: %s\n",
 256         size-18, ret, errmsg);
 257
 258     if ( ret == 20 || ret == 21 )
 259         printf("\tPASS return value of %d or %d as expected\n",
 260             20, 21);
 261     else
 262         printf("\tFAIL return value %d, expected %d or %d\n", ret,
 263             20, 21 );
 264
 265     exit(0);
 266
 267 }
 268
 269 #endif
 270