| /* |
| * Copyright (c) 2000 Silicon Graphics, Inc. All Rights Reserved. |
| * |
| * This program is free software; you can redistribute it and/or modify it |
| * under the terms of version 2 of the GNU General Public License as |
| * published by the Free Software Foundation. |
| * |
| * This program is distributed in the hope that it would be useful, but |
| * WITHOUT ANY WARRANTY; without even the implied warranty of |
| * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. |
| * |
| * Further, this software is distributed without any warranty that it is |
| * free of the rightful claim of any third person regarding infringement |
| * or the like. Any license provided herein, whether implied or |
| * otherwise, applies only to this software file. Patent licenses, if |
| * any, provided herein do not apply to combinations of this program with |
| * other software, or any other product whatsoever. |
| * |
| * You should have received a copy of the GNU General Public License along |
| * with this program; if not, write the Free Software Foundation, Inc., 59 |
| * Temple Place - Suite 330, Boston MA 02111-1307, USA. |
| * |
| * Contact information: Silicon Graphics, Inc., 1600 Amphitheatre Pkwy, |
| * Mountain View, CA 94043, or: |
| * |
| * http://www.sgi.com |
| * |
| * For further information regarding this notice, see: |
| * |
| * http://oss.sgi.com/projects/GenInfo/NoticeExplan/ |
| */ |
| #include <stdio.h> |
| #include <sys/param.h> |
| #include <string.h> /* memset */ |
| #include <stdlib.h> /* rand */ |
| #include "databin.h" |
| |
| #if UNIT_TEST |
| #include <malloc.h> |
| #endif |
| |
| static char Errmsg[80]; |
| |
| void |
| databingen (mode, buffer, bsize, offset) |
| int mode; /* either a, c, r, o, z or C */ |
| char *buffer; /* buffer pointer */ |
| int bsize; /* size of buffer */ |
| int offset; /* offset into the file where buffer starts */ |
| { |
| int ind; |
| |
| switch (mode) |
| { |
| default: |
| case 'a': /* alternating bit pattern */ |
| memset(buffer,0x55,bsize); |
| break; |
| |
| case 'c': /* checkerboard pattern */ |
| memset(buffer,0xf0,bsize); |
| break; |
| |
| case 'C': /* */ |
| for (ind=0;ind< bsize;ind++) { |
| buffer[ind] = ((offset+ind)%8 & 0177); |
| } |
| break; |
| |
| case 'o': |
| memset(buffer,0xff,bsize); |
| break; |
| |
| case 'z': |
| memset(buffer,0x0,bsize); |
| break; |
| |
| case 'r': /* random */ |
| for (ind=0;ind< bsize;ind++) { |
| buffer[ind] = (rand () & 0177) | 0100; |
| } |
| } |
| } |
| |
| /*********************************************************************** |
| * |
| * return values: |
| * >= 0 : error at byte offset into the file, offset+buffer[0-(bsize-1)] |
| * < 0 : no error |
| ***********************************************************************/ |
| int |
| databinchk(mode, buffer, bsize, offset, errmsg) |
| int mode; /* either a, c, r, z, o, or C */ |
| char *buffer; /* buffer pointer */ |
| int bsize; /* size of buffer */ |
| int offset; /* offset into the file where buffer starts */ |
| char **errmsg; |
| { |
| int cnt; |
| unsigned char *chr; |
| long expbits; |
| long actbits; |
| |
| chr = (unsigned char *) buffer; |
| |
| if (errmsg != NULL) { |
| *errmsg = Errmsg; |
| } |
| |
| switch (mode) |
| { |
| default: |
| case 'a': /* alternating bit pattern */ |
| expbits=0x55; |
| break; |
| |
| case 'c': /* checkerboard pattern */ |
| expbits=0xf0; |
| break; |
| |
| case 'C': /* counting pattern */ |
| for (cnt=0;cnt< bsize;cnt++) { |
| expbits = ((offset+cnt)%8 & 0177); |
| |
| if (buffer[cnt] != expbits) { |
| sprintf(Errmsg, |
| "data mismatch at offset %d, exp:%#lo, act:%#o", |
| offset+cnt, expbits, buffer[cnt]); |
| return offset+cnt; |
| } |
| } |
| sprintf(Errmsg, "all %d bytes match desired pattern", bsize); |
| return -1; |
| |
| case 'o': |
| expbits=0xff; |
| break; |
| |
| case 'z': |
| expbits=0; |
| break; |
| |
| case 'r': |
| return -1; /* no check can be done for random */ |
| } |
| |
| for (cnt=0; cnt<bsize; chr++, cnt++) { |
| actbits = (long)*chr; |
| |
| if (actbits != expbits) { |
| sprintf(Errmsg, "data mismatch at offset %d, exp:%#lo, act:%#lo", |
| offset+cnt, expbits, actbits); |
| return offset+cnt; |
| } |
| } |
| |
| sprintf(Errmsg, "all %d bytes match desired pattern", bsize); |
| return -1; /* all ok */ |
| } |
| |
| #if UNIT_TEST |
| |
| /*********************************************************************** |
| * main for doing unit testing |
| ***********************************************************************/ |
| int |
| main(ac, ag) |
| int ac; |
| char **ag; |
| { |
| |
| int size=1023; |
| int offset; |
| int number; |
| unsigned char *buffer; |
| int ret; |
| char *errmsg; |
| |
| if ((buffer=(unsigned char *)malloc(size)) == NULL) { |
| perror("malloc"); |
| exit(2); |
| } |
| |
| |
| printf("***** for a ****************************\n"); |
| databingen('a', buffer, size, 0); |
| printf("databingen('a', buffer, %d, 0)\n", size); |
| |
| ret=databinchk('a', buffer, size, 0, &errmsg); |
| printf("databinchk('a', buffer, %d, 0, &errmsg) returned %d: %s\n", |
| size, ret, errmsg); |
| if (ret == -1) |
| printf("\tPASS return value of -1 as expected\n"); |
| else |
| printf("\tFAIL return value %d, expected -1\n", ret); |
| |
| offset=232400; |
| ret=databinchk('a', &buffer[1], size-1, offset, &errmsg); |
| printf("databinchk('a', &buffer[1], %d, %d, &errmsg) returned %d: %s\n", |
| size, offset, ret, errmsg); |
| if (ret == -1) |
| printf("\tPASS return value of -1 as expected\n"); |
| else |
| printf("\tFAIL return value %d, expected -1\n", ret); |
| |
| buffer[15]= 0x0; |
| printf("changing char 15 (offset (%d+15) = %d) to 0x0\n", offset, offset+15); |
| number=offset+15; |
| |
| ret=databinchk('a', &buffer[1], size-1, offset+1, &errmsg); |
| printf("databinchk('a', &buffer[1], %d, %d, &errmsg) returned %d: %s\n", |
| size-1, offset+1, ret, errmsg); |
| if (ret == number) |
| printf("\tPASS return value of %d as expected\n", number); |
| else |
| printf("\tFAIL return value %d, expected %d\n", ret, number); |
| |
| |
| |
| printf("***** for c ****************************\n"); |
| databingen('c', buffer, size, 0); |
| printf("databingen('c', buffer, %d, 0)\n", size); |
| |
| ret=databinchk('c', buffer, size, 0, &errmsg); |
| printf("databinchk('c', buffer, %d, 0, &errmsg) returned %d: %s\n", |
| size, ret, errmsg); |
| if (ret == -1) |
| printf("\tPASS return value of -1 as expected\n"); |
| else |
| printf("\tFAIL return value %d, expected -1\n", ret); |
| |
| offset=232400; |
| ret=databinchk('c', &buffer[1], size-1, offset, &errmsg); |
| printf("databinchk('c', &buffer[1], %d, %d, &errmsg) returned %d: %s\n", |
| size, offset, ret, errmsg); |
| if (ret == -1) |
| printf("\tPASS return value of -1 as expected\n"); |
| else |
| printf("\tFAIL return value %d, expected -1\n", ret); |
| |
| buffer[15]= 0x0; |
| printf("changing char 15 (offset (%d+15) = %d) to 0x0\n", offset, offset+15); |
| number=offset+15; |
| |
| ret=databinchk('c', &buffer[1], size-1, offset+1, &errmsg); |
| printf("databinchk('c', &buffer[1], %d, %d, &errmsg) returned %d: %s\n", |
| size-1, offset+1, ret, errmsg); |
| if (ret == number) |
| printf("\tPASS return value of %d as expected\n", number); |
| else |
| printf("\tFAIL return value %d, expected %d\n", ret, number); |
| |
| printf("***** for C ****************************\n"); |
| |
| databingen('C', buffer, size, 0); |
| printf("databingen('C', buffer, %d, 0)\n", size); |
| |
| ret=databinchk('C', buffer, size, 0, &errmsg); |
| printf("databinchk('C', buffer, %d, 0, &errmsg) returned %d: %s\n", |
| size, ret, errmsg); |
| if (ret == -1) |
| printf("\tPASS return value of -1 as expected\n"); |
| else |
| printf("\tFAIL return value %d, expected -1\n", ret); |
| |
| offset=18; |
| ret=databinchk('C', &buffer[18], size-18, 18, &errmsg); |
| printf("databinchk('C', &buffer[18], %d, 18, &errmsg) returned %d: %s\n", |
| size-18, ret, errmsg); |
| if (ret == -1) |
| printf("\tPASS return value of -1 as expected\n"); |
| else |
| printf("\tFAIL return value %d, expected -1\n", ret); |
| |
| buffer[20]= 0x0; |
| buffer[21]= 0x0; |
| printf("changing char 20 and 21 to 0x0 (offset %d and %d)\n", 20, |
| 21); |
| |
| ret=databinchk('C', &buffer[18], size-18, 18, &errmsg); |
| printf("databinchk('C', &buffer[18], %d, 18, &errmsg) returned %d: %s\n", |
| size-18, ret, errmsg); |
| |
| if (ret == 20 || ret == 21) |
| printf("\tPASS return value of %d or %d as expected\n", |
| 20, 21); |
| else |
| printf("\tFAIL return value %d, expected %d or %d\n", ret, |
| 20, 21 ); |
| |
| exit(0); |
| |
| } |
| |
| #endif |