datagram.c

s3c44b0+sl811读写u盘程序

            switch (*(p+1))
            {
            case 'b':
			case 'B':                           /* -B: binary mode */
                binmode = 1;
                break;
		    
            case 'u':
            case 'U':                           /* -U: display UDP segments */
                udpdebug = 1;
                break;
			case 'v':
            case 'V':                           /* -V: verbose packet display */
                netdebug |= 1;
                break;
			case 'x':
            case 'X':                           /* -X: hex packet display */
                netdebug |= 2;
                break;
            default:
                err = 1;
            }
        }
        else if ((client==0) && (c>=0x30)&&(c<=0x39))       /* If client mode.. */
        {
            remnode.ip = atoip(p);     /* Get destination IP address */
			while((*p++)!=' ');
			p--;
            client++;
        }
        else if (client==1)
        {
            if ((remport=str2service(p))!=0)
                remnode.port = remport;         /* ..then port number */
            else
            {
                Uart_Printf("Unrecognised port number/service '%s'\n", argv[args]);
                err++;
            }
			while(((*p++)!=' ')&&((*p++)!='\0'));
			p--;
            client++;
        }
        else if (client == 2)
        {
            cmd = p;//argv[args];                   /* ..then command string */
            
            while(((*p++)!=' ')&&((*p++)!='\0'));
			p--;
            client++;
        }
    }
    Uart_Printf("   ");
    Uart_Printf(cmd);

	//init. ethernet controller--------------------------------------
    if (err)                                    /* Prompt user if error */
        disp_usage();
    else if (!(dtype=read_netconfig(&locnode)))//初始化本地节点，启动以太网控制器
        //Uart_Printf("Invalid configuration '%s'\n", cfgfile);
        Uart_Printf("Initialize node failed!");
    else
    {
        remnode.dtype = genframe.g.dtype = dtype;   /* Set frame driver type */
        gfp = &genframe;                            /* Get pointer to frame */
        Uart_Printf("IP %s", ipstr(locnode.ip, temps));
        Uart_Printf(" mask %s", ipstr(locnode.mask, temps));
        if (locnode.gate)
            Uart_Printf(" gate %s", ipstr(locnode.gate, temps));
        if (dtype & DTYPE_ETHER)
            Uart_Printf(" Ethernet %s", ethstr(locnode.mac, temps));
        else if (dtype & DTYPE_SLIP)
            cstate = ARP_RX;
        Uart_Printf("\n中断本测试请按开发板上的key0、key2、key3");
        if (client)
        {
            Uart_Printf("Contacting %s...\n", ipstr(remnode.ip, temps));
            memcpy((BYTE *)(remnode.mac), bcast, MACLEN);
        }
		else
			Uart_Printf("Enter Server mode...\n");
				
        //mstimeout(&mstime, 0);
        //Delay(0);
        while (!breakflag)                      /* Main loop.. */
        {
            if (client /*&& (mstimeout(&mstime, TRYTIME)*/ || (cstate!=lastcstate))
            {
				if (tries++ > MAXTRIES)         /* Giving up? */
						breakflag = 1;
				else if (cstate == ARP_TX)      /* (Re)transmit ARP? */
                {
					put_frame(gfp, make_arp(gfp, &locnode, &remnode, ARPREQ));

                }
                else if (cstate == ARP_RX)      /* ARP response? */
                {
                    if (in){
                        udp_transmit_text(gfp, &locnode, &remnode, in);
                    	}
                    else{
                          temp=strlen(cmd);                    
                          udp_transmit(gfp, &locnode, &remnode, cmd, temp);//strlen(cmd));

                    	}
                }
                else if (cstate == CLIENT_DONE) /* UDP response? */
                {
                    do_poll(gfp); 
					while (st = do_receive1(gfp))
                    {
                        do_poll(gfp); 
                    }
					breakflag = 1;
                }
                lastcstate = cstate;            /* Record state-change */
              }
			do_poll(gfp);                       /* Poll net drivers */
			st = do_receive1(gfp);               /* Receive frames */
            cstate = st ? st : cstate;          /* ..maybe change state */
            if (c=Readkey())             /* if Any exintX pressed,break... */
                breakflag = 1;
        }
        close_net(dtype);                       /* Shut down net driver */
    }
    
    Uart_Printf("Press any key to exit");
    while(!(rUTRSTAT0 & 0x1)); //Receive data read
	temp=RdURXH0();
}

/* Check for incoming packets, send response if required
** Return state-change value if ARP response or datagram received */
int do_receive1(GENFRAME *gfp)
{
    NODE node;
    ARPKT *arp;
    IPKT *ip;
    ICMPKT *icmp;
    int rxlen, txlen, len, ret=0;
	//BYTE i,*p;

    if ((rxlen=get_frame(gfp)) > 0)                 /* Any incoming frames? */
    {
        ip = getframe_datap(gfp);
        if (is_arp(gfp, rxlen))
        {                                           /* ARP response? */
            //arp = getframe_datap(gfp);
            arp = &arpkt;//////采用全局变量传递指针
            
            if (arp->op==ARPREQ && arp->dip==locnode.ip)
            {                                       /* ARP request? */
                node.ip = arp->sip;                 /* Make ARP response */
                memcpy((BYTE *)(node.mac), (BYTE *)(arp->smac), MACLEN);
                txlen = make_arp(gfp, &locnode, &node, ARPRESP);
                put_frame(gfp, txlen);              /* Send packet */
            }
            if (arp->op==ARPRESP && arp->dip==locnode.ip)
            {                                       /* ARP response? */
                memcpy((BYTE *)(remnode.mac), (BYTE *)(arp->smac), MACLEN);
                ret = ARP_RX;
            }
        }
        else if ((rxlen=is_ip(gfp, rxlen))!=0)// &&    /* IP datagram? */
        {
          ip=&ipkt;/////////用全局变量传递指针
          if((ip->i.dip==locnode.ip) ||( ip->i.dip==BCASTIP))
          {
            getip_srce(gfp, &node);
            if ((len=is_icmp(ip, rxlen))!=0)        /* ICMP? */
            {
                icmp = (ICMPKT *)ip;
                if (icmp->c.type == ICREQ)          /* Echo request? */
                {
                    len = (WORD)maxi(len, 0);       /* Make response */
                    txlen = make_icmp(gfp, &locnode, &node, ICREP,
                                      icmp->c.code, (WORD)len);
                    put_frame(gfp, txlen);          /* Send packet */
                }
                else if (icmp->c.type == ICUNREACH)
                    Uart_Printf("ICMP: destination unreachable\n");
            }
            else if ((len=is_udp(ip, rxlen))!=0)    /* UDP? */
            {
                ret = udp_receive(gfp, maxi(len, 0));
            }
          }
        }
    }
    return(ret);
}

/* Receive a UDP datagram: return non-0 if client state-change */
int udp_receive(GENFRAME *gfp, int len)
{
    UDPKT *udp;
    int ret=0;
    NODE loc, rem;

    udp = getframe_datap(gfp);
	swap_udp(udp);
    getudp_srce(gfp, &rem);                         /* Get srce & dest nodes */
    getudp_locdest(gfp, &loc);
    if (loc.port == locnode.port)                   /* Client response */
    {
        Uart_Printf("\n");
		disp_data(udp->data, len);                  /* Display data.. */
        ret = CLIENT_DONE;                          /* ..and exit */
    }
    else if (loc.port == ECHOPORT)                  /* Echo req: resend data */
        udp_transmit(gfp, &loc, &rem, (BYTE *)(udp->data), len);
    else                                            /* Unreachable: send ICMP */
    {
        swap_udp(udp);
        put_frame(gfp, icmp_unreach(gfp, &loc, &rem, UNREACH_PORT));
    }
    return(ret);
}

/* Send a UDP datagram, given destination node, data and length */
void udp_transmit(GENFRAME *gfp, NODE *sp, NODE *dp, void *dat, int len)
{
    UDPKT *udp;
	int templen;

    udp = getframe_datap(gfp);
    memmove((BYTE *)(udp->data), dat, len);
	templen=maxi(len,0);
	templen=make_udp(gfp, sp, dp, (WORD)templen);
    put_frame(gfp, templen);
}

/* Send a UDP datagram, given destination node, data and length */
void udp_transmit_text(GENFRAME *gfp, NODE *sp, NODE *dp, char *in)
{
    UDPKT *udp;
    WORD len;
	int i;
	char *p;

    udp = getframe_datap(gfp);
    len = strlen(in);//fread(udp->data, 1, sizeof(udp->data), in);
    p=(char *)udp->data;
    for(i=0;i<len;i++)
		*p++=*in++;
		
    put_frame(gfp, make_udp(gfp, sp, dp, len));
}

/* Convert string (numeric or alphabetic) into a port number, 0 if error */
WORD str2service(char *str)
{
    WORD port=0;

    if ((*str>=0x30)&&(*str<=0x39))//isdigit(*str))
        port = atoi(str);
    else if (!strncmp(str, "echo",4))
        port = ECHOPORT;
    else if (!strncmp(str, "daytime",7))
        port = DAYPORT;
    else if (!strncmp(str, "time",4))
        port = TIMEPORT;
    else if (!strncmp(str, "snmp",4))
        port = SNMPORT;
    return(port);
}

/* Display the incoming UDP data */
void disp_data(BYTE *data, int len)
{
    BYTE b;
    int i, n, oset=0;

    if (!binmode)
    {
        while (len--)
        {
            b = *data++;
            if ((b>=' '&&b<='~') || b=='\n')
               Uart_SendByte(b);
            else
               Uart_SendByte(' ');
        }
    }
    else while (len > 0)
    {
        n = mini(len, 24);
        Uart_Printf("%04X: ", oset);
        for (i=0; i<n; i++)
            Uart_Printf("%02X ", data[i]);
        Uart_Printf("\n      ");
        for (i=0; i<n; i++, data++)
        {
            Uart_SendByte(' ');
            Uart_SendByte(*data>=' ' && *data<='~' ? *data : 0);
            Uart_SendByte(' ');
        }
        len -= n;
        oset += n;
        Uart_SendByte('\n');
    }
}


/* EOF */