Weird Segmantation fault on writing a to a file c - c

Question

In this case of the project that am working on , am receiving a message and i want to send a response by writing a message to the file descriptor.But the problem is that the write function returns Segmentation Fault and i dont know why. For example i receive a message going to the right case and send response by writing to a file when i use write it shows that the message went to the destination but after that returns segmentation fault.If instead of write use a printf it works and doesnt show segmentation fault .Can any one help me with that ?
typedef enum operation{
insert,
read_reg,
info,
error
}Operation;
typedef struct request{
Operation operation;
int ID;
int counter;
}Request;
int **regs;
fd=open(port,O_RDWR|O_NOCTTY);
if(fd==-1){
perror(port);
exit(1);
}
regs=(int **)malloc(2*sizeof(int*));
if(regs==NULL){
printf("Cant create data base for registers\n");
exit(1);
}
for(int i=1;i<=2;i++){
regs[i]=(int*)malloc(SIZE*sizeof(int));
if(regs[i]==NULL){
exit(1);
}
}
regs[1][0]=1;
regs[2][0]=3;
char str[12];
char buffer[255];
while(1){
//Clean buffer
memset(buffer,0,SIZE);
FD_ZERO(&readfd);
FD_SET(fd,&readfd);
timeout.tv_sec=100;
timeout.tv_usec=0;
status=select(40,&readfd,NULL,NULL,&timeout);
if(status==0){
printf("Cannot receive data from client\n");
printf("\tTime Out\n");
exit(1);
}
read_num=read(fd,buffer,sizeof(buffer));
if(read_num<0) perror("Error in reading file descriptor\n");
if(read_num>0){
//while(1){
fl.l_type = F_RDLCK; /* read lock */
fl.l_whence = SEEK_SET; /* beginning of file */
fl.l_start = 0; /* offset from l_whence */
fl.l_len = 0; /* length, 0 = to EOF */
fl.l_pid = getpid(); /* PID */
fcntl(fd, F_SETLKW, &fl);
request=parse_request(buffer);
if(request){
switch(request->operation){
case info:
write(fd,"OK\n",1);
break;
case read_reg:
write(fd,"OK\n",1);
printf("prepei na diabaso reg\n");
break;
case insert:
printf("edo vazo timi\n");
write(fd,"OK\n",1);
break;
case error:
printf("prepei na petakso error\n");
write(fd,"OK\n",1);
break;
}
printf("prepei na me deis meta apo kathe break\n");
}
printf("kai edw prepei na me deis \n");
fl.l_type = F_UNLCK;
fcntl(fd, F_SETLK, &fl); // unset lock
//}
}
printf("edw ?\n");
}
parse_request is a function that splits the message and determines information about it.
Request *parse_request(char *buffer){
char *token=NULL,*value=NULL;
Request *rep=NULL;
char string_split[4];
int i=0;
rep=(Request*)malloc(sizeof(Request));
rep->counter=0;
token=strtok(buffer,"=");
//extract value
value=strtok(NULL,"=");
token=strtok(token,"+");
//extract register
token=strtok(NULL,"+");
//Set up registers ID
rep->ID=atoi(&token[strlen(token)-1]);
//Set up operation type
if(!value){
rep->operation=read_reg;
//printf("Operation :read\n");
}else{
if(strcmp(value,"?")==0){
rep->operation=info;
//printf("Operation :info\n");
}else{
//check if number is valid
if(isValid(value,rep)==1){
rep->operation=insert;
//printf("Operation :insert\n");
//printf("am gonna insert value:%d\n",atoi(value));
regs[rep->ID][rep->counter++]=atoi(value);
printf("%d\n",regs[rep->ID][rep->counter++]=atoi(value));
}else{
rep->operation=error;
//printf("Operation :error\n");
}
}
}
return rep;
}

Answer 1

regarding a buffer that contains:
AT+<REG>=<VALUE>
the first call to strtok() replaces the + with a NUL byte.
A second call to strtok() does not find a + in the buffer, so continues to search through memory until some 'random' + is encountered.
Now you have a pointer token pointing to memory that your program should not access.
Then the program tries to output the memory at that 'invalid' 'token' pointer. The result is a seq fault event.