Unique number sequencer problem

[weaknessforcats]

Have you stepped though this with your debugger??

[Silvine]

Hi,

I have writtten this C script to produce a series of numbers. However, it seems there is an overflow somewhere and a storage buffer is being filled when it should not be filled.

The output is controlled by the variables DIGIT_LENGTH and MAX

Where DIGIT_LENGTH is the number of digits in a sequence and MAX is how high to count these digits in a sequence.

For example, DIGIT_LENGTH = 3;
and MAX = 3;

This outputs
12
13
23
123

But in this version of the program there are trailing numbers in the sequence...

122
132
233
123

Something like that -

Where are the rxPtr[ao].string[2] getting filled on or before the first pass?

[Silvine]

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

typedef struct {int key; int digit; int string[2];}person;
//int pass(man a[]);


int main() {

int apo;
int x;


int digit_length = 3;

double max = 4;

FILE *fp;

int store = 1000000;

person *txPtr;
if( (txPtr = calloc( store, sizeof(person) )) == NULL) {

printf("txPtr:Insufficient memory\n");
abort();

} else {
printf("txPtr:Sufficient Memory\n");
memset(txPtr,0,sizeof(txPtr));
}
person *rxPtr;
if( (rxPtr = calloc( store, sizeof(person) )) == NULL) {

printf("rxPtr:Insufficient memory\n");
abort();

} else {
printf("rxPtr:Sufficient Memory\n");
memset(rxPtr,0,sizeof(rxPtr));
}


	int y;
	int ao = 0;

	int key = 1;
	char name[24];
	int digit;
	int z;

		char start[24];
		int ad = 0;
		int outputl = 0;
		char buffer[24];
int xyz;
for(x = 0; x < max; x++) {
 txPtr[x].key = x+1;
 txPtr[x].digit = 1;
 for(xyz = 0; xyz < digit_length; xyz++){
  txPtr[x].string[xyz] = 0;
 }
 txPtr[x].string[0] = x+1;
}





if (( fp = fopen( "unique2.db", "wt" )) == NULL){
	perror( "Error opening data file\n" );
	 return -1;
}

int digital = 0;
int digitstore[digit_length];
int zyx;


for(x = key; x < max; x++) {
    printf("\nOne\n");
	y = 0;
		key = txPtr[y].key;
		digit = txPtr[y].digit;
		memset(rxPtr,0,sizeof(rxPtr));
		for(xyz = 0; xyz < digit_length; xyz++) {
	      digitstore[xyz] = txPtr[y].string[xyz];
		 }

        while(!key == 0) {
				digit = digit + 1;
		for( z = key; z < max; z++ ) {
			ad = z+1;
			rxPtr[ao].key = ad;
			rxPtr[ao].digit = digit;

			for(xyz = 0; xyz < digit_length; xyz++) {
			if (xyz == digit - 1) {
				rxPtr[ao].string[xyz] = ad;
			} else {
				rxPtr[ao].string[xyz] = digitstore[xyz];
			}
			}




			for(xyz = digit; xyz < digit_length; xyz++){
				for(zyx = xyz; zyx < digit_length; zyx++) {
				printf("%d",rxPtr[ao].string[xyz]);
			}
			}
			printf(" Key:%d, z: %d, Digit: %d,String:%d %d %d\n",ad,z,digit,rxPtr[ao].string[0],rxPtr[ao].string[1],rxPtr[ao].string[2]);
			if(digit == digit_length) {
			fwrite(rxPtr[ao].string, sizeof(rxPtr[ao].string),1,fp);
			}
						ao++;
			if(digit > digit_length) {
			printf("\nExceeded digit limit.\n");
			printf("\nFreeing Memory\n\n");
			free(txPtr);
			free(rxPtr);
			abort();
			}
		}
		y++;
		key = txPtr[y].key;
		digit = txPtr[y].digit;

		for(xyz = 0; xyz < digit_length; xyz++) {
	      digitstore[xyz] = txPtr[y].string[xyz];
		  }

}
 printf("Mem cop");
    memset(txPtr, 0, sizeof(txPtr));
	memcpy(txPtr, rxPtr, store);
	memset(rxPtr, 0, sizeof(rxPtr));
	ao = 0;
}

free(txPtr);
free(rxPtr);

if ( fclose(fp) != 0)
{
	fprintf(stderr, "Error closing file.\n");
	return -2;
}
return 0;
}