vbatts/grub
1
0
Fork 0
Code Issues Pull requests Releases Wiki Activity

Initial Implementation of TFTP protocol and new protocol structs.

Browse source
This commit is contained in:
Manoel R. Abranches 2010-04-27 18:05:35 -03:00
parent 4931b0984b
commit 066528b4b1
23 changed files with 789 additions and 6 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

8
conf/powerpc-ieee1275.rmk
View file

@ -3,7 +3,10 @@
# Images.
kernel_img_HEADERS += ieee1275/ieee1275.h
<<<<<<< TREE
kernel_img_HEADERS += ieee1275/ieee1275.h \
command.h i18n.h env_private.h net/ip.h net/udp.h net/ethernet.h net/arp.h net/tftp.h\
net/ieee1275/interface.h net/type_net.h net.h net/interface.h net/protocol.h net/netbuff.h
# Programs
pkglib_PROGRAMS = kernel.img
@ -20,7 +23,8 @@ kernel_img_SOURCES = kern/powerpc/ieee1275/startup.S kern/ieee1275/cmain.c \
kern/ieee1275/openfw.c disk/ieee1275/ofdisk.c \
kern/parser.c kern/partition.c kern/env.c kern/$(target_cpu)/dl.c \
kern/generic/millisleep.c kern/time.c \
symlist.c kern/$(target_cpu)/cache.S
symlist.c kern/$(target_cpu)/cache.S net/ip.c net/tftp.c net/udp.c net/ethernet.c net/arp.c \
net/ieee1275/interface.c net/interface.c net/protocol.c net/netbuff.c
kernel_img_CFLAGS = $(COMMON_CFLAGS)
kernel_img_ASFLAGS = $(COMMON_ASFLAGS)
kernel_img_LDFLAGS += $(COMMON_LDFLAGS) -Wl,-N,-S,-Ttext,0x200000,-Bstatic

19
include/grub/net.h
View file

@ -22,15 +22,20 @@
#include <grub/types.h>
#include <grub/err.h>
#include <grub/list.h>
#include <grub/net/netbuff.h>
struct grub_net_card;
struct grub_net_card_driver
{
grub_err_t (*send) (struct grub_net_card *dev, void *buf,
grub_size_t buflen);
grub_size_t (*recv) (struct grub_net_card *dev, void *buf,
grub_size_t buflen);
grub_err_t (*send) (struct grub_net_card *dev,struct grub_net_buff *nb);
grub_size_t (*recv) (struct grub_net_card *dev,struct grub_net_buff *nb);
};
struct grub_net_addr
{
grub_uint8_t *addr;
grub_size_t len;
};
struct grub_net_card
@ -38,6 +43,12 @@ struct grub_net_card
struct grub_net_card *next;
char *name;
struct grub_net_card_driver *driver;
/*transport layer address*/
struct grub_net_addr *tla;
/*internet layer address*/
struct grub_net_addr *ila;
/*link layer address*/
struct grub_net_addr *lla;
void *data;
};

23
include/grub/net/arp.h Normal file
View file

@ -0,0 +1,23 @@
#ifndef GRUB_NET_ARP_HEADER
#define GRUB_NET_ARP_HEADER 1
#include <grub/net/ethernet.h>
struct arprequest {
grub_int16_t hwtype; /* hardware type (must be ARPHRD_ETHER) */
grub_int16_t protocol; /* protocol type (must be ETH_P_IP) */
grub_int8_t hwlen; /* hardware address length (must be 6) */
grub_int8_t protolen; /* protocol address length (must be 4) */
grub_uint16_t opcode; /* ARP opcode */
grub_uint8_t shwaddr[6]; /* sender's hardware address */
grub_uint32_t sipaddr; /* sender's IP address */
grub_uint8_t thwaddr[6]; /* target's hardware address */
grub_uint32_t tipaddr; /* target's IP address */
}__attribute__ ((packed));
struct arp_pkt{
struct etherhdr ether;
struct arprequest arpr;
} __attribute__ ((packed));
#endif

7
include/grub/net/device.h Normal file
View file

@ -0,0 +1,7 @@
struct grub_net_card
{
struct grub_net_card *next;
char *name;
struct grub_net_card_driver *driver;
void *data;
};

12
include/grub/net/ethernet.h Normal file
View file

@ -0,0 +1,12 @@
#ifndef GRUB_NET_ETHERNET_HEADER
#define GRUB_NET_ETHERNET_HEADER 1
#include <grub/misc.h>
struct etherhdr {
grub_uint8_t dst[6];
grub_uint8_t src[6];
grub_uint16_t type;
} __attribute__ ((packed)) ;
void ethernet_ini(void);
void ethernet_fini(void);
#endif

21
include/grub/net/ieee1275/interface.h Normal file
View file

@ -0,0 +1,21 @@
#ifndef GRUB_IEEE1275_INTERFACE_HEADER
#define GRUB_IEEE1275_INTERFACE_HEADER 1
#include <grub/misc.h>
#include <grub/ieee1275/ieee1275.h>
#include <grub/ieee1275/ofnet.h>
grub_ofnet_t EXPORT_VAR(grub_net);
grub_bootp_t EXPORT_VAR(bootp_pckt);
grub_uint32_t get_server_ip(void);
grub_uint32_t get_client_ip(void);
grub_uint8_t* get_server_mac (void);
grub_uint8_t* get_client_mac (void);
int send_card_buffer (void *buffer,int buff_len);
int get_card_buffer (void *buffer,int buff_len);
int card_open (void);
int card_close (void);
#endif

17
include/grub/net/interface.h Normal file
View file

@ -0,0 +1,17 @@
#ifndef GRUB_INTERFACE_HEADER
#define GRUB_INTERFACE_HEADER
#include <grub/net.h>
#include <grub/net/protocol.h>
/*
extern struct grub_net_topprotocol;
struct grub_net_interface
{
struct grub_net_card *card;
struct grub_net_topprotocol* topprot;
struct grub_net_addr *tla;
struct grub_net_addr *ila;
struct grub_net_addr *lla;
};
*/
#endif

25
include/grub/net/ip.h Normal file
View file

@ -0,0 +1,25 @@
#ifndef GRUB_NET_IP_HEADER
#define GRUB_NET_IP_HEADER 1
#include <grub/misc.h>
struct iphdr {
grub_uint8_t verhdrlen;
grub_uint8_t service;
grub_uint16_t len;
grub_uint16_t ident;
grub_uint16_t frags;
grub_uint8_t ttl;
grub_uint8_t protocol;
grub_uint16_t chksum;
grub_uint32_t src;
grub_uint32_t dest;
} __attribute__ ((packed)) ;
#define IP_UDP 17 /* UDP protocol */
#define IP_BROADCAST 0xFFFFFFFF
grub_uint16_t ipchksum(void *ipv, int len);
void ipv4_ini(void);
void ipv4_fini(void);
#endif

27
include/grub/net/netbuff.h Normal file
View file

@ -0,0 +1,27 @@
#ifndef GRUB_NETBUFF_HEADER
#define GRUB_NETBUFF_HEADER
#include <grub/misc.h>
#define NETBUFF_ALIGN 2048
#define NETBUFFMINLEN 64
struct grub_net_buff
{
/*Pointer to the start of the buffer*/
char *head;
/*Pointer to the data */
char *data;
/*Pointer to the tail */
char *tail;
/*Pointer to the end of the buffer*/
char *end;
};
grub_err_t grub_netbuff_put (struct grub_net_buff *net_buff ,grub_size_t len);
grub_err_t grub_netbuff_unput (struct grub_net_buff *net_buff ,grub_size_t len);
grub_err_t grub_netbuff_push (struct grub_net_buff *net_buff ,grub_size_t len);
grub_err_t grub_netbuff_pull (struct grub_net_buff *net_buff ,grub_size_t len);
grub_err_t grub_netbuff_reserve (struct grub_net_buff *net_buff ,grub_size_t len);
struct grub_net_buff * grub_netbuff_alloc ( grub_size_t len );
#endif

50
include/grub/net/protocol.h Normal file
View file

@ -0,0 +1,50 @@
#ifndef GRUB_PROTOCOL_HEADER
#define GRUB_PROTOCOL_HEADER
#include <grub/err.h>
#include <grub/net/protocol.h>
#include <grub/net/netbuff.h>
#include <grub/net.h>
struct protocol_operations;
struct grub_net_protocol;
struct grub_net_interface;
struct grub_net_protocol
{
struct grub_net_protocol *next;
char *name;
grub_err_t (*open) (struct grub_net_interface* inf,
struct grub_net_protocol *prot, struct grub_net_buff *nb);
grub_err_t (*open_confirm) (struct grub_net_interface *inf,
struct grub_net_protocol *prot, struct grub_net_buff *nb);
grub_err_t (*get_payload) (struct grub_net_interface *inf,
struct grub_net_protocol *prot, struct grub_net_buff *nb);
grub_err_t (*get_payload_confirm) (struct grub_net_interface* inf,
struct grub_net_protocol *prot, struct grub_net_buff *nb);
grub_err_t (*close) (struct grub_net_interface *inf,
struct grub_net_protocol *prot, struct grub_net_buff *nb);
grub_err_t (*send) (struct grub_net_interface *inf ,
struct grub_net_protocol *prot, struct grub_net_buff *nb);
grub_err_t (*recv) (struct grub_net_interface *inf ,
struct grub_net_protocol *prot, struct grub_net_buff *nb);
};
typedef struct grub_net_protocol *grub_net_protocol_t;
struct grub_net_interface
{
struct grub_net_card *card;
struct grub_net_protocol* prot;
char *path;
char *username;
char *password;
/*transport layer addres*/
struct grub_net_addr *tla;
/*internet layer addres*/
struct grub_net_addr *ila;
/*link layer addres*/
struct grub_net_addr *lla;
};
void grub_protocol_register (grub_net_protocol_t prot);
void grub_protocol_unregister (grub_net_protocol_t prot);
#endif

74
include/grub/net/tftp.h Normal file
View file

@ -0,0 +1,74 @@
#ifndef GRUB_NET_TFTP_HEADER
#define GRUB_NET_TFTP_HEADER 1
#include <grub/misc.h>
#include <grub/net/ethernet.h>
#include <grub/net/udp.h>
/* IP port for the MTFTP server used for Intel's PXE */
#define MTFTP_SERVER_PORT 75
#define MTFTP_CLIENT_PORT 76
#define TFTP_DEFAULTSIZE_PACKET 512
#define TFTP_MAX_PACKET 1432
/* IP port for the TFTP server */
#define TFTP_SERVER_PORT 69
#define TFTP_CLIENT_PORT 2000
/* We define these based on what's in arpa/tftp.h. We just like our
* names better, cause they're clearer */
#define TFTP_RRQ 1
#define TFTP_WRQ 2
#define TFTP_DATA 3
#define TFTP_ACK 4
#define TFTP_ERROR 5
#define TFTP_OACK 6
#define TFTP_CODE_EOF 1
#define TFTP_CODE_MORE 2
#define TFTP_CODE_ERROR 3
#define TFTP_CODE_BOOT 4
#define TFTP_CODE_CFG 5
#define TFTP_EUNDEF 0 /* not defined */
#define TFTP_ENOTFOUND 1 /* file not found */
#define TFTP_EACCESS 2 /* access violation */
#define TFTP_ENOSPACE 3 /* disk full or allocation exceeded */
#define TFTP_EBADOP 4 /* illegal TFTP operation */
#define TFTP_EBADID 5 /* unknown transfer ID */
#define TFTP_EEXISTS 6 /* file already exists */
#define TFTP_ENOUSER 7 /* no such user */
#define TFTP_DEFAULT_FILENAME "kernel"
/* * own here because this is cleaner, and maps to the same data layout.
* */
struct tftphdr {
grub_uint16_t opcode;
union {
grub_int8_t rrq[TFTP_DEFAULTSIZE_PACKET];
struct {
grub_uint16_t block;
grub_int8_t download[TFTP_MAX_PACKET];
} data;
struct {
grub_uint16_t block;
} ack;
struct {
grub_uint16_t errcode;
grub_int8_t errmsg[TFTP_DEFAULTSIZE_PACKET];
} err;
struct {
grub_int8_t data[TFTP_DEFAULTSIZE_PACKET+2];
} oack;
} u;
} __attribute__ ((packed)) ;
void tftp_ini(void);
void tftp_fini(void);
#endif

7
include/grub/net/type_net.h Normal file
View file

@ -0,0 +1,7 @@
#ifndef GRUB_TYPES_NET_HEADER
#define GRUB_TYPES_NET_HEADER 1
#define UDP_PCKT 0x11
#define IP_PCKT 0x0800
#endif

22
include/grub/net/udp.h Normal file
View file

@ -0,0 +1,22 @@
#ifndef GRUB_NET_UDP_HEADER
#define GRUB_NET_UDP_HEADER 1
#include <grub/misc.h>
/*
typedef enum
{
GRUB_PROT_TFTP
} protocol_type;
*/
#define GRUB_PROT_TFTP 1
struct udphdr {
grub_uint16_t src;
grub_uint16_t dst;
grub_uint16_t len;
grub_uint16_t chksum;
} __attribute__ ((packed));
void udp_ini(void);
void udp_fini(void);
#endif

0
net/arp.c Normal file
View file

0
net/device.c Normal file
View file

54
net/ethernet.c Normal file
View file

@ -0,0 +1,54 @@
#include <grub/misc.h>
#include <grub/mm.h>
#include <grub/net/ethernet.h>
#include <grub/net/ip.h>
#include <grub/net/arp.h>
#include <grub/net/ieee1275/interface.h>
#include <grub/net/netbuff.h>
#include <grub/net/protocol.h>
static grub_err_t
send_ethernet_packet (struct grub_net_interface *inf, struct grub_net_protocol *prot __attribute__ ((unused))
,struct grub_net_buff *nb)
{
struct etherhdr *eth;
grub_err_t err;
if((err = grub_netbuff_push (nb,sizeof(*eth)) ) != GRUB_ERR_NONE)
return err;
eth = (struct etherhdr *) nb->data;
grub_memcpy (eth->src,inf->card->lla->addr,6 * sizeof (grub_uint8_t ));
grub_memcpy (eth->dst,inf->lla->addr,6 * sizeof (grub_uint8_t ));
eth->type = 0x0800;
return inf->card->driver->send(inf->card,nb);
}
static struct grub_net_protocol grub_ethernet_protocol =
{
.name = "udp",
.send = send_ethernet_packet
};
void ethernet_ini(void)
{
grub_protocol_register (&grub_ethernet_protocol);
}
void ethernet_fini(void)
{
grub_protocol_unregister (&grub_ethernet_protocol);
}
/*
int read_ethernet_packet(buffer,bufflen, int type)
{
struct etherhdr eth;
eth.type = 0;
get_card_buffer (&eth,sizeof (eth));
}*/

80
net/ieee1275/interface.c Normal file
View file

@ -0,0 +1,80 @@
#include <grub/net/ieee1275/interface.h>
#include <grub/mm.h>
grub_uint32_t get_server_ip (void)
{
return bootp_pckt->siaddr;
}
grub_uint32_t get_client_ip (void)
{
return bootp_pckt->yiaddr;
}
grub_uint8_t* get_server_mac (void)
{
grub_uint8_t *mac;
mac = grub_malloc (6 * sizeof(grub_uint8_t));
mac[0] = 0x00 ;
mac[1] = 0x11 ;
mac[2] = 0x25 ;
mac[3] = 0xca ;
mac[4] = 0x1f ;
mac[5] = 0x01 ;
return mac;
}
grub_uint8_t* get_client_mac (void)
{
grub_uint8_t *mac;
mac = grub_malloc (6 * sizeof (grub_uint8_t));
mac[0] = 0x0a ;
mac[1] = 0x11 ;
mac[2] = 0xbd ;
mac[3] = 0xe3 ;
mac[4] = 0xe3 ;
mac[5] = 0x04 ;
return mac;
}
static grub_ieee1275_ihandle_t handle;
int card_open (void)
{
grub_ieee1275_open (grub_net->dev , &handle);
return 1;//error
}
int card_close (void)
{
if (handle)
grub_ieee1275_close (handle);
return 0;
}
int send_card_buffer (void *buffer,int buff_len)
{
int actual;
grub_ieee1275_write (handle,buffer,buff_len,&actual);
return actual;
}
int get_card_buffer (void *buffer,int buff_len)
{
int actual;
grub_ieee1275_read (handle,buffer,buff_len,&actual);
return actual;
}

0
net/interface.c Normal file
View file

95
net/ip.c Normal file
View file

@ -0,0 +1,95 @@
#include <grub/net/ip.h>
#include <grub/net/type_net.h>
#include <grub/net/ieee1275/interface.h>
#include <grub/misc.h>
#include <grub/net/ethernet.h>
#include <grub/net/netbuff.h>
#include <grub/net/protocol.h>
#include <grub/mm.h>
struct grub_net_protocol *grub_ipv4_prot;
grub_uint16_t
ipchksum(void *ipv, int len)
{
grub_uint16_t *ip = (grub_uint16_t *)ipv;
grub_uint32_t sum = 0;
len >>= 1;
while (len--) {
sum += *(ip++);
if (sum > 0xFFFF)
sum -= 0xFFFF;
}
return((~sum) & 0x0000FFFF);
}
static grub_err_t
send_ip_packet (struct grub_net_interface *inf, struct grub_net_protocol *prot, struct grub_net_buff *nb )
{
struct iphdr *iph;
grub_err_t err;
if((err = grub_netbuff_push(nb,sizeof(*iph)) ) != GRUB_ERR_NONE)
return err;
iph = (struct iphdr *) nb->data;
/*FIXME dont work in litte endian machines*/
//grub_uint8_t ver = 4;
//grub_uint8_t hdrlen = sizeof (struct iphdr)/4;
iph->verhdrlen = (4<<4 | 5);
iph->service = 0;
iph->len = sizeof(*iph);
iph->ident = 0x2b5f;
iph->frags = 0;
iph->ttl = 0xff;
iph->protocol = 0x11;
//grub_memcpy(&(iph->src) ,inf->card->ila->addr,inf->card->ila->len);
iph->src = *((grub_uint32_t *)inf->card->ila->addr);
//grub_memcpy(&(iph->dest) ,inf->ila->addr,inf->ila->len);
iph->dest = *((grub_uint32_t *)inf->ila->addr);
iph->chksum = 0 ;
iph->chksum = ipchksum((void *)nb->head, sizeof(*iph));
return prot->next->send(inf,prot->next,nb);
}
static struct grub_net_protocol grub_ipv4_protocol =
{
.name = "ipv4",
.send = send_ip_packet,
.recv = NULL
};
void ipv4_ini(void)
{
grub_protocol_register (&grub_ipv4_protocol);
}
void ipv4_fini(void)
{
grub_protocol_unregister (&grub_ipv4_protocol);
}
/*
int read_ip_packet (void *buffer,int *bufflen)
{
struct iphdr iph;
iph.protocol = 0;
while ( iph.protocol != IP_UDP)
{
read_ethernet_packet(buffer,bufflen,IP_PROTOCOL);
grub_memcpy (&iph,buffer,sizeof (iph));
}
buffer += sizeof (iph);
*buff_len -= sizeof (iph);
}*/

72
net/netbuff.c Normal file
View file

@ -0,0 +1,72 @@
/*
* GRUB -- GRand Unified Bootloader
* Copyright (C) 2010 Free Software Foundation, Inc.
*
* GRUB is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* GRUB is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with GRUB. If not, see <http://www.gnu.org/licenses/>.
*/
#include <grub/err.h>
#include <grub/misc.h>
#include <grub/mm.h>
#include <grub/net/netbuff.h>
grub_err_t grub_netbuff_put (struct grub_net_buff *net_buff ,grub_size_t len)
{
net_buff->tail += len;
if (net_buff->tail > net_buff->end)
return grub_error (GRUB_ERR_OUT_OF_RANGE, "out of the packet range.");
return GRUB_ERR_NONE;
}
grub_err_t grub_netbuff_unput (struct grub_net_buff *net_buff ,grub_size_t len)
{
net_buff->tail -= len;
if (net_buff->tail < net_buff->head)
return grub_error (GRUB_ERR_OUT_OF_RANGE, "out of the packet range.");
return GRUB_ERR_NONE;
}
grub_err_t grub_netbuff_push (struct grub_net_buff *net_buff ,grub_size_t len)
{
net_buff->data -= len;
if (net_buff->data < net_buff->head)
return grub_error (GRUB_ERR_OUT_OF_RANGE, "out of the packet range.");
return GRUB_ERR_NONE;
}
grub_err_t grub_netbuff_pull (struct grub_net_buff *net_buff ,grub_size_t len)
{
net_buff->data += len;
if (net_buff->data > net_buff->end)
return grub_error (GRUB_ERR_OUT_OF_RANGE, "out of the packet range.");
return GRUB_ERR_NONE;
}
grub_err_t grub_netbuff_reserve (struct grub_net_buff *net_buff ,grub_size_t len)
{
net_buff->data += len;
net_buff->tail += len;
if ((net_buff->tail > net_buff->end) || (net_buff->data > net_buff->end))
return grub_error (GRUB_ERR_OUT_OF_RANGE, "out of the packet range.");
return GRUB_ERR_NONE;
}
struct grub_net_buff * grub_netbuff_alloc ( grub_size_t len )
{
if (len < NETBUFFMINLEN)
len = NETBUFFMINLEN;
len = ALIGN_UP (len,NETBUFF_ALIGN);
return (struct grub_net_buff *) grub_memalign (len,NETBUFF_ALIGN);
}

21
net/protocol.c Normal file
View file

@ -0,0 +1,21 @@
#include <grub/net/protocol.h>
static grub_net_protocol_t grub_net_protocols;
void grub_protocol_register (grub_net_protocol_t prot)
{
prot->next = grub_net_protocols;
grub_net_protocols = prot;
}
void grub_protocol_unregister (grub_net_protocol_t prot)
{
grub_net_protocol_t *p, q;
for (p = &grub_net_protocols, q = *p; q; p = &(q->next), q = q->next)
if (q == prot)
{
*p = q->next;
break;
}
}

102
net/tftp.c Normal file
View file

@ -0,0 +1,102 @@
#include <grub/misc.h>
#include <grub/net/tftp.h>
#include <grub/net/udp.h>
#include <grub/net/ip.h>
#include <grub/net/ethernet.h>
#include <grub/net/netbuff.h>
#include <grub/net/protocol.h>
#include <grub/net/ieee1275/interface.h>
#include <grub/ieee1275/ieee1275.h>
#include <grub/time.h>
/*send read request*/
static grub_err_t
send_tftp_rr (struct grub_net_interface *inf, struct grub_net_protocol *prot,struct grub_net_buff *nb)
{
/*Start TFTP header*/
struct tftphdr *tftph;
char *rrq;
int rrqlen;
int hdrlen;
grub_err_t err;
if((err = grub_netbuff_push (nb,sizeof(*tftph))) != GRUB_ERR_NONE)
return err;
tftph = (struct tftphdr *) nb->data;
rrq = (char *) tftph->u.rrq;
rrqlen = 0;
tftph->opcode = TFTP_RRQ;
grub_strcpy (rrq,inf->path);
rrqlen += grub_strlen (inf->path) + 1;
rrq += grub_strlen (inf->path) + 1;
/*passar opcoes como parametro ou usar default?*/
grub_strcpy (rrq,"octet");
rrqlen += grub_strlen ("octet") + 1;
rrq += grub_strlen ("octet") + 1;
grub_strcpy (rrq,"blksize");
rrqlen += grub_strlen("blksize") + 1;
rrq += grub_strlen ("blksize") + 1;
grub_strcpy (rrq,"1024");
rrqlen += grub_strlen ("1024") + 1;
rrq += grub_strlen ("1024") + 1;
grub_strcpy (rrq,"tsize");
rrqlen += grub_strlen ("tsize") + 1;
rrq += grub_strlen ("tsize") + 1;
grub_strcpy (rrq,"0");
rrqlen += grub_strlen ("0") + 1;
rrq += grub_strlen ("0") + 1;
hdrlen = sizeof (tftph->opcode) + rrqlen;
grub_netbuff_unput (nb,nb->tail - (nb->data+hdrlen));
return prot->next->send(inf,prot->next,nb);
}
/*
int send_tftp_ack(int block, int port){
tftp_t pckt;
int pcktlen;
pckt.opcode = TFTP_ACK;
pckt.u.ack.block = block;
pcktlen = sizeof (pckt.opcode) + sizeof (pckt.u.ack.block);
port = 4;
return 0;// send_udp_packet (&pckt,pcktlen,TFTP_CLIENT_PORT,port);
}
*/
static struct grub_net_protocol grub_tftp_protocol =
{
.name = "tftp",
.open = send_tftp_rr
};
void tftp_ini(void)
{
grub_protocol_register (&grub_tftp_protocol);
}
void tftp_fini(void)
{
grub_protocol_unregister (&grub_tftp_protocol);
}
/*
int read_tftp_pckt (grub_uint16_t port, void *buffer, int &buff_len){
read_udp_packet (port,buffer,buff_len);
}*/

59
net/udp.c Normal file
View file

@ -0,0 +1,59 @@
#include <grub/net/udp.h>
#include <grub/net/ip.h>
#include <grub/net/type_net.h>
#include <grub/net/netbuff.h>
#include <grub/net/protocol.h>
/*Assumes that there is allocated memory to the header before the buffer address. */
static grub_err_t
send_udp_packet (struct grub_net_interface *inf, struct grub_net_protocol *prot, struct grub_net_buff *nb)
{
struct udphdr *udph;
grub_err_t err;
if((err = grub_netbuff_push (nb,sizeof(*udph)) ) != GRUB_ERR_NONE)
return err;
udph = (struct udphdr *) nb->data;
udph->src = *((grub_uint16_t *) inf->card->tla->addr);
udph->dst = *((grub_uint16_t *) inf->tla->addr);
/*no chksum*/
udph->chksum = 0;
udph->len = sizeof (sizeof (*udph)) + nb->end - nb->head;
return prot->next->send(inf,prot->next,nb);
}
static struct grub_net_protocol grub_udp_protocol =
{
.name = "udp",
.send = send_udp_packet
};
void udp_ini(void)
{
grub_protocol_register (&grub_udp_protocol);
}
void udp_fini(void)
{
grub_protocol_unregister (&grub_udp_protocol);
}
/*
int read_udp_packet (grub_uint16_t port,void *buffer,int *buff_len)
{
struct udphdr udph;
udph.dst = 0;
while ( udph.dst != port)
{
read_ip_packet (buffer,bufflen);
grub_memcpy (&udph,buffer,sizeof (udph));
}
buffer += sizeof (udph);
*buff_len -= sizeof (udph);
}*/