int main()
{
char* developer = (char*) malloc(sizeof(char)*50);
// identify com parametros ok
if(identify2(developer, 50) == 0) printf("a) developer: %s \n", developer);
// identify com size menor que o esperado
if(identify2(developer, 10) == 0) printf("b) developer: %s \n", developer);
developer = (char*) realloc(developer, 10);
if(developer == NULL) return -1;
// identify com char* com alocacao menor que a esperada:
// faz com que ocorra um crash na chamada do free()
// ja que o strcpy() SOBRESCREVE UM ESPACO ALEM DO ALOCADO
// assim, ao chamar o free(), o programa tenta apagar mais
// do que deve, causando o invalid access
// if(identify2(developer, 50) == 0) printf("c) developer: %s \n", developer);
// identify com char* com alocacao e size menores que os esperados
if(identify2(developer, 10) == 0) printf("d) developer: %s \n", developer);
printf("\n");
free(developer);
return 0;
}
int main()
{
char buffer[256];
identify2(buffer,256);
puts(buffer);
return 0;
}
/**
Chama da função identify2 da biblioteca e coloca o string de retorno na tela
*/
void cmdWho(void) {
char name[256];
int err = identify2(name, 256);
if (err) {
printf ("Erro: %d\n", err);
return;
}
printf ("%s\n", name);
}
void loadpg( int net , int totalnodes )
{
int i , node1 , node2 , pnode , PorE , distance , splitL , capacity ;
int savepnode , bound1 , bound2 , j , pnode1 , pnode2 ;
QUADPTR qptr ;
GNODEPTR gptr , g2ptr , gptr1 , gptr2 ;
LIST2PTR lptr ;
qptr = pinlist ;
for( i = 1 ; i <= totalnodes ; i++ ) {
node1 = qptr->node1 ;
node2 = qptr->node2 ;
distance = qptr->distance ;
PorE = qptr->PorE ;
j = identify2( &node1, &node2, distance, &bound1, &bound2, &gptr );
if( j == 0 ) {
fprintf(fpo,"pin number: %d of net: %d was supposed to ",
i , net ) ;
fprintf(fpo,"lie between nodes: %d and %d\n", node1, node2);
fprintf(fpo,"However, the graph doesn't have an edge ");
fprintf(fpo,"between these two nodes\n");
exit(0);
} else if( j == 1 ) {
fprintf(fpo,"pin number: %d of net: %d ", i , net ) ;
fprintf(fpo,"specified to lie between nodes: %d and %d\n",
node1 , node2 ) ;
fprintf(fpo,"is not within the scope of this channel\n");
exit(0);
}
splitL = bound2 - bound1 ;
capacity = gptr->capacity ;
if( node1 <= numnodes && node2 <= numnodes ) {
gptr->length = VLARGE ;
gptr->cost = VLARGE ;
gptr = gnodeArray[node2] ;
while( gptr->node != node1 ) {
gptr = gptr->next ;
}
gptr->length = VLARGE ;
gptr->cost = VLARGE ;
} else {
if( gnodeArray[node1] == gptr ) {
gnodeArray[node1] = gptr->next ;
free( gptr ) ;
} else {
g2ptr = gnodeArray[node1] ;
while( g2ptr->next != gptr ) {
g2ptr = g2ptr->next ;
}
g2ptr->next = gptr->next ;
free( gptr ) ;
}
if( gnodeArray[node2]->node == node1 ) {
gptr = gnodeArray[node2] ;
gnodeArray[node2] = gnodeArray[node2]->next ;
free( gptr ) ;
} else {
g2ptr = gnodeArray[node2] ;
while( g2ptr->next->node != node1 ) {
g2ptr = g2ptr->next ;
}
gptr = g2ptr->next ;
g2ptr->next = gptr->next ;
free( gptr ) ;
}
}
pnode = i + numnodes ;
if( PorE == 1 ) {
savepnode = i ;
pnodeArray[i].eptr = 0 ;
} else {
lptr = pnodeArray[savepnode].equiv ;
pnodeArray[i].eptr = savepnode ;
pnodeArray[savepnode].equiv = (LIST2PTR) malloc(sizeof(LIST2));
pnodeArray[savepnode].equiv->next = lptr ;
pnodeArray[savepnode].equiv->node = i ;
}
distance -= bound1 ;
gnodeArray[pnode] = (GNODEPTR) malloc( sizeof(GNODE) ) ;
gnodeArray[pnode]->node = node1 ;
gnodeArray[pnode]->length = distance ;
gnodeArray[pnode]->ilength = distance ;
gnodeArray[pnode]->cost = distance ;
gnodeArray[pnode]->capacity = capacity ;
gnodeArray[pnode]->inactive = 0 ;
gnodeArray[pnode]->einactive = 0 ;
gnodeArray[pnode]->next = (GNODEPTR) malloc( sizeof(GNODE) ) ;
gnodeArray[pnode]->next->node = node2 ;
gnodeArray[pnode]->next->length = splitL - distance ;
gnodeArray[pnode]->next->ilength = splitL - distance ;
gnodeArray[pnode]->next->cost = splitL - distance ;
gnodeArray[pnode]->next->capacity = capacity ;
gnodeArray[pnode]->next->inactive = 0 ;
gnodeArray[pnode]->next->einactive = 0 ;
gnodeArray[pnode]->next->next = (GNODEPTR) NULL ;
gptr = gnodeArray[node1] ;
gnodeArray[node1] = (GNODEPTR) malloc( sizeof(GNODE) ) ;
gnodeArray[node1]->next = gptr ;
gnodeArray[node1]->node = pnode ;
gnodeArray[node1]->ilength = distance ;
gnodeArray[node1]->length = distance ;
gnodeArray[node1]->cost = distance ;
gnodeArray[node1]->capacity = capacity ;
gnodeArray[node1]->inactive = 0 ;
gnodeArray[node1]->einactive = 0 ;
gptr = gnodeArray[node2] ;
gnodeArray[node2] = (GNODEPTR) malloc( sizeof(GNODE) ) ;
gnodeArray[node2]->next = gptr ;
gnodeArray[node2]->node = pnode ;
gnodeArray[node2]->ilength = splitL - distance ;
gnodeArray[node2]->length = splitL - distance ;
gnodeArray[node2]->cost = splitL - distance ;
gnodeArray[node2]->capacity = capacity ;
gnodeArray[node2]->inactive = 0 ;
gnodeArray[node2]->einactive = 0 ;
qptr = qptr->next ;
}
for( i = 1 ; i <= totalnodes ; i++ ) {
pnode1 = i + numnodes ;
gptr = gnodeArray[pnode1] ;
/* Mitch added check if gptr is null */
for( ; gptr != (GNODEPTR) NULL ; gptr = (gptr ? gptr->next : gptr)) {
pnode2 = gptr->node ;
j = pnode2 - numnodes ;
if( pnode2 <= numnodes || j < i ) {
continue ;
}
if( (pnodeArray[i].eptr != 0) && (pnodeArray[j].eptr != 0) ) {
if( pnodeArray[i].eptr != pnodeArray[j].eptr ) {
continue ;
}
} else if( pnodeArray[i].eptr == 0 && pnodeArray[j].eptr == 0){
continue ;
} else {
if( pnodeArray[i].eptr != 0 ) {
if( pnodeArray[i].eptr != j ) {
continue ;
}
} else {
if( pnodeArray[j].eptr != i ) {
continue ;
}
}
}
gptr1 = gnodeArray[pnode1] ;
gptr2 = gnodeArray[pnode2] ;
gptr = gptr1 ;
/* Mitch added check if gptr is null */
for( ; gptr; ) {
if( gptr->node == pnode2 ) {
gptr->cost = VLARGE ;
break ;
}
gptr = gptr->next ;
}
gptr = gptr2 ;
/* Mitch added check if gptr is null */
for( ; gptr; ) {
if( gptr->node == pnode1 ) {
gptr->cost = VLARGE ;
break ;
}
gptr = gptr->next ;
}
}
}
return ;
}
