Problem med tftp-klient

Din dator skapar en socket med random port, du skickar till serverns port 69, och den svarar till din socket med data från sin random-port, och du sparar undan denna nya address. Såvitt jag kan se så gör du helt rätt.

Men är du dock säker på vad filen du begär innehåller? Är det en tom fil så borde det väl vara korrekt med 0byte data.
Är du säker på att serverimplementationen är korrekt?

Och så lite småsaker:

struct tftp_data *td = malloc(512);
...
recv = recvfrom(tc->sock,td,512,0,(struct sockaddr *)&(tc->peer_addr), &(tc->addrlen));

Din buffer borde väl vara minst 516byte (ett data-paket är (enligt RFC1350) 2byte opcode, 2byte block-id, 0-512byte data.)

tc->sock = socket(PF_INET, SOCK_DGRAM, 0);
...
tc->sock = socket(PF_INET, SOCK_DGRAM, 0);

Du kör socket() två gånger.

strcat(concat,tc->fname); // fname innehåller strängen "name"
strcat(concat,"0");
strcat(concat,tc->mode); // mode innehåller strängen "octet"
strcat(concat,"0");
int s = TFTP_RRQ_HDR_LEN + TFTP_RRQ_LEN(tc->fname,tc->mode);

Nollorna ska väl vara null-terminatorer? Isf. måste du väl lägga in riktiga nollor och inte ascii nollor.

Om du ändrar:

char concat[] = "";
´
strcat(concat,tc->fname); // fname innehåller strängen "name"
strcat(concat,"0");
strcat(concat,tc->mode); // mode innehåller strängen "octet"
strcat(concat,"0");
int s = TFTP_RRQ_HDR_LEN + TFTP_RRQ_LEN(tc->fname,tc->mode);
printf("s = %d\n",s);
struct tftp_rrq *rrq = malloc(s);
rrq->opcode = htons(1);
strcpy(rrq->req, concat);

till:

struct tftp_rrq *rrq = malloc(512);
rrq->opcode = htons(1);    
int s=sprintf(rrq->req,"%s%c%s",tc->fname,0,tc->mode)+3; //+1 för att sprintf räknar inte med avslutande null-terminering. +2 för opcode.

Så borde det bli rätt. Dock borde du väl kontrollera returvärdet från malloc, eller ändra:

struct tftp_rrq {
	u_int16_t opcode;
	char req[0];
};

till:

struct tftp_rrq {
	u_int16_t opcode;
	char req[512];
};

Så slipper du ju malloc helt och hållet..

En printning av c som innehåller "test.txt\0octet" (\0 är NULL) ska ge "test.txt".

printf:s tankeprocess vid printf("%s\n",c):

Okej, jag ska skriva ut strängen c följt av en radbrytning.
Läs tecken från sträng c.
läs tecken, t, skriv ut
läs tecken, e, skriv ut
läs tecken, s, skriv ut
läs tecken, t, skriv ut
läs tecken, ., skriv ut
läs tecken, t, skriv ut
läs tecken, x, skriv ut
läs tecken, t, skriv ut
läs tecken, NULL, strängen är slut
skriv ut radbrytning
Färdig.

Det är alltså så nullterminerade strängar fungerar..

Om du vill skriva ut det som kommer efter den första nulltermineringen kan du väl göra nått i stil med:

printf("%s\n",c+strlen(c)+1);

Detta borde väl ge dig "octet", dock inte så intressant iom. att din socket inte bryr sig om saker som strängar och nulltermineringar utan bara kastar ut det antal bytes som du sagt åt den..

Om det är nått som du inte får att fungera så måste du vara lite mer specifik..

[code]
#include <sys/types.h>
#include <sys/socket.h>
#include <stdio.h>
#include <string.h>
#include <stdint.h>
#include <netinet/in.h>

#define BUFFER_SIZE 512

void handleMsgError(char* buffer);
void handleMsgData(char* buffer);

int main(int argc,char** argv) {

char buffer[BUFFER_SIZE];
size_t buffer_size=0;

int socket_fd = socket(AF_INET,SOCK_DGRAM,0);

struct sockaddr_in server_addr;
server_addr.sin_family = AF_INET;
server_addr.sin_addr.s_addr = inet_addr("127.0.0.1");
server_addr.sin_port = htons(69);

//Build a Read Request packet
int16_t opcode = htons(1);
memcpy(buffer,&opcode,2);
buffer_size=3; //opcode (2byte) + nullterminator (1byte)
buffer_size+=sprintf(buffer+2,"%s%c%s","hello.txt",0,"octet");

//Send request
sendto(socket_fd,buffer,buffer_size,0,(struct sockaddr*)&server_addr,sizeof(server_addr));

struct sockaddr_in server2_addr;
socklen_t server2_socklen;
buffer_size=recvfrom(socket_fd,buffer,BUFFER_SIZE,0,(struct sockaddr*)&server2_addr,&server2_socklen);

//Null terminate the packet
buffer[buffer_size]=0;

memcpy(&opcode,buffer,2);
opcode=ntohs(opcode);

switch(opcode) {
case 3:
handleMsgData(buffer+2);
break;
case 5:
handleMsgError(buffer+2);
break;
case 1:
case 2:
case 4:
fprintf(stderr,"Unsupported opcode: %d\n",opcode);
default:
fprintf(stderr,"Illegal opcode: %d\n",opcode);
break;
}

}

void handleMsgError(char* buffer) {
int16_t errcode;
memcpy(&errcode,buffer,2);
errcode=ntohs(errcode);

fprintf(stderr,"Error msg received.

 [msg="\"%s\""]\n",errcode,buffer+2);
}

void handleMsgData(char* buffer) {
	int16_t block;
	memcpy(&block,buffer,2);
	block = ntohs(block);

	fprintf(stderr,"Data msg received. [block="%d"]",block);
	printf("%s",buffer+2);
}

Ovanstående kod fungerar iaf.