本人电路板使用的网卡为CS8900，鉴于其datasheet过于庞大没有做深究只是了解了一下其IO模式。其驱动程序如下
#include <linux/config.h>
#include <linux/version.h>
#include <linux/module.h>
#include <linux/kernel.h>
#include <linux/types.h>
#include <linux/errno.h>
#include <linux/ioport.h>
#include <linux/init.h>
#include <linux/delay.h>
#include <asm/irq.h>
#include <asm/hardware.h>
#include <asm/io.h>
#include <asm/arch/regs-gpio.h>
#include <linux/netdevice.h>
#include <linux/etherdevice.h>
#include <linux/skbuff.h>
#include "cirrus.h"
#if 0
//#elif CONFIG_ARCH_CSB226
# define CIRRUS_DEFAULT_IO 0xF8000300
# define CIRRUS_DEFAULT_IRQ IRQ_GPIO(16)
/* PTX: uggly hack... */
# define CS8900_OFF 0x04
# define CS8900_PPTR *(volatile u32 *)(CIRRUS_DEFAULT_IO+0x05*CS8900_OFF)
# define CS8900_PDATA *(volatile u32 *)(CIRRUS_DEFAULT_IO+0x06*CS8900_OFF)
//#else
# define CIRRUS_DEFAULT_IO 0
# define CIRRUS_DEFAULT_IRQ 0
#endif
typedef struct {
struct net_device_stats stats;//状态结构
u16 txlen;
int char_devnum;
spinlock_t lock;
} cirrus_t;
typedef struct {
u16 io_base; /* I/O Base Address */
u16 irq; /* Interrupt Number */
u16 dma; /* DMA Channel Numbers */
u32 mem_base; /* Memory Base Address */
u32 rom_base; /* Boot PROM Base Address */
u32 rom_mask; /* Boot PROM Address Mask */
u8 mac[6]; /* Individual Address */
} cirrus_eeprom_t;
/*
* I/O routines
*/
static inline u16 cirrus_read (struct net_device *dev,u16 reg)
{
CIRRUS_outw (reg, dev->base_addr, PP_Address);
return (CIRRUS_inw (dev->base_addr, PP_Data));
}
static inline void cirrus_write (struct net_device *dev,u16 reg,u16 value)
{
CIRRUS_outw (reg, dev->base_addr, PP_Address);
CIRRUS_outw (value, dev->base_addr, PP_Data);
}
static inline void cirrus_set (struct net_device *dev,u16 reg,u16 value)
{
cirrus_write (dev,reg,cirrus_read (dev,reg) | value);
}
static inline void cirrus_clear (struct net_device *dev,u16 reg,u16 value)
{
cirrus_write (dev,reg,cirrus_read (dev,reg) & ~value);
}
static inline void cirrus_frame_read (struct net_device *dev,struct sk_buff *skb,u16 length)
{
CIRRUS_insw (dev->base_addr, 0, skb_put (skb,length), (length + 1) / 2);
}
static inline void cirrus_frame_write (struct net_device *dev,struct sk_buff *skb)
{
CIRRUS_outsw (dev->base_addr, 0, skb->data, (skb->len + 1) / 2);//使用port0读写数据包
}
/*
* Debugging functions
*/
#ifdef DEBUG
static inline int printable (int c)
{
return ((c >= 32 && c <= 126) ||
(c >= 174 && c <= 223) ||
(c >= 242 && c <= 243) ||
(c >= 252 && c <= 253));
}
static void dump16 (struct net_device *dev,const u8 *s,size_t len)
{
int i;
char str[128];
if (!len) return;
*str = '/0';
for (i = 0; i < len; i++) {
if (i && !(i % 4)) strcat (str," ");
sprintf (str,"%s%.2x ",str,s[i]);
}
for ( ; i < 16; i++) {
if (i && !(i % 4)) strcat (str," ");
strcat (str," ");
}
strcat (str," ");
for (i = 0; i < len; i++) sprintf (str,"%s%c",str,printable (s[i]) ? s[i] : '.');
printk (KERN_DEBUG "%s: %s/n",dev->name,str);
}
static void hexdump (struct net_device *dev,const void *ptr,size_t size)
{
const u8 *s = (u8 *) ptr;
int i;
for (i = 0; i < size / 16; i++, s += 16) dump16 (dev,s,16);
dump16 (dev,s,size % 16);
}
static void dump_packet (struct net_device *dev,struct sk_buff *skb,const char *type)
{
printk (KERN_INFO "%s: %s %d byte frame %.2x:%.2x:%.2x:%.2x:%.2x:%.2x to %.2x:%.2x:%.2x:%.2x:%.2x:%.2x type %.4x/n",
dev->name,
type,
skb->len,
skb->data[0],skb->data[1],skb->data[2],skb->data[3],skb->data[4],skb->data[5],
skb->data[6],skb->data[7],skb->data[8],skb->data[9],skb->data[10],skb->data[11],
(skb->data[12] << 8) | skb->data[13]);
if (skb->len < 0x100) hexdump (dev,skb->data,skb->len);
}
#endif /* #ifdef DEBUG */
/*
* Driver functions
*/
static void cirrus_receive (struct net_device *dev)//读取数据到套接字缓冲
{
cirrus_t *priv = (cirrus_t *) dev->priv;
struct sk_buff *skb;
u16 status,length;
status = cirrus_read (dev,PP_RxStatus);//读取数据包状态
length = cirrus_read (dev,PP_RxLength);//读取数据包长度
if (!(status & RxOK)) {//出错
priv->stats.rx_errors++;
if ((status & (Runt | Extradata))) priv->stats.rx_length_errors++;
if ((status & CRCerror)) priv->stats.rx_crc_errors++;
return;
}
if ((skb = dev_alloc_skb (length + 4)) == NULL) {//建立套接字缓冲区和数据缓冲区
priv->stats.rx_dropped++;
return;
}
skb->dev = dev;
skb_reserve (skb,2);//将data下移2，以便IP头16B对齐
cirrus_frame_read (dev,skb,length);//将数据复制到缓冲区中
#ifdef DEBUG
dump_packet (dev,skb,"recv");
#endif /* #ifdef DEBUG */
skb->protocol = eth_type_trans (skb,dev);//网络层位何种协议
netif_rx (skb);//将数据上传给网络层
dev->last_rx = jiffies;//读取时间
priv->stats.rx_packets++;
priv->stats.rx_bytes += length;//更新状态
}
static int cirrus_send_start (struct sk_buff *skb,struct net_device *dev)//启动发送数据
{
cirrus_t *priv = (cirrus_t *) dev->priv;
u16 status;
spin_lock_irq(&priv->lock);
netif_stop_queue (dev);//停止队列
cirrus_write (dev,PP_TxCMD,TxStart (After5));//Start transmission after 5 bytes are in the CS8900A
cirrus_write (dev,PP_TxLength,skb->len);//提取套接字缓冲长度
status = cirrus_read (dev,PP_BusST);//读取ISA总线状态
if ((status & TxBidErr)) {//出错
spin_unlock_irq(&priv->lock);
printk (KERN_WARNING "%s: Invalid frame size %d!/n",dev->name,skb->len);
priv->stats.tx_errors++;
priv->stats.tx_aborted_errors++;
priv->txlen = 0;
return (1);
}
if (!(status & Rdy4TxNOW)) {//未准备好
spin_unlock_irq(&priv->lock);
printk (KERN_WARNING "%s: Transmit buffer not free!/n",dev->name);
priv->stats.tx_errors++;
priv->txlen = 0;
/* FIXME: store skb and send it in interrupt handler */
return (1);
}
cirrus_frame_write (dev,skb);//将数据从内存中复制到片内ram中
spin_unlock_irq(&priv->lock);
#ifdef DEBUG
dump_packet (dev,skb,"send");
#endif /* #ifdef DEBUG */
dev->trans_start = jiffies;//记录发送时间
dev_kfree_skb (skb);//释放套接字缓冲
priv->txlen = skb->len;
return (0);
}
static irqreturn_t cirrus_interrupt (int irq,void *id,struct pt_regs *regs)//中断处理函数
{
struct net_device *dev = (struct net_device *) id;
cirrus_t *priv;
u16 status;
int handled = 0;
if (dev->priv == NULL) {
printk (KERN_WARNING "%s: irq %d for unknown device./n",dev->name,irq);
handled = 1;
return 0;//IRQ_RETVAL(handled);
}
priv = (cirrus_t *) dev->priv;
while ((status = cirrus_read (dev,PP_ISQ))) {//读中断寄存器
handled = 1;
switch (RegNum (status)) {
case RxEvent:
cirrus_receive (dev);//接受中断
handled = 1;
break;
case TxEvent://发送中断
priv->stats.collisions += ColCount (cirrus_read (dev,PP_TxCOL));//冲突加1
if (!(RegContent (status) & TxOK)) {//发送失败
priv->stats.tx_errors++;
if ((RegContent (status) & Out_of_window)) priv->stats.tx_window_errors++;
if ((RegContent (status) & Jabber)) priv->stats.tx_aborted_errors++;
break;
} else if (priv->txlen) {
priv->stats.tx_packets++;
priv->stats.tx_bytes += priv->txlen;
}
priv->txlen = 0;
netif_wake_queue (dev);//开启队列
handled = 1;
break;
case BufEvent:
if ((RegContent (status) & RxMiss)) {
u16 missed = MissCount (cirrus_read (dev,PP_RxMISS));
priv->stats.rx_errors += missed;
priv->stats.rx_missed_errors += missed;
}
if ((RegContent (status) & TxUnderrun)) {
priv->stats.tx_errors++;
priv->stats.tx_fifo_errors++;
}
// FIXME: if Rdy4Tx, transmit last sent packet (if any)
priv->txlen = 0;
netif_wake_queue (dev);
handled = 1;
break;
case TxCOL:
priv->stats.collisions += ColCount (cirrus_read (dev,PP_TxCOL));
handled = 1;
break;
case RxMISS:
status = MissCount (cirrus_read (dev,PP_RxMISS));
priv->stats.rx_errors += status;
priv->stats.rx_missed_errors += status;
handled = 1;
break;
}
}
if(!handled) printk("Invalid cs8900 irq/n");
return IRQ_HANDLED;//IRQ_RETVAL(handled);
}
static void cirrus_transmit_timeout (struct net_device *dev)//发送超时处理
{
cirrus_t *priv = (cirrus_t *) dev->priv;
priv->stats.tx_errors++;
priv->stats.tx_heartbeat_errors++;
priv->txlen = 0;
netif_wake_queue (dev);
}
static int cirrus_start (struct net_device *dev)//打开
{
int result;
/* valid ethernet address? */
if (!is_valid_ether_addr(dev->dev_addr)) {
printk(KERN_ERR "%s: invalid ethernet MAC address/n",dev->name);
return (-EINVAL);
}
/* install interrupt handler */
printk("%s: requesting interrupt %i/n", __FUNCTION__, dev->irq);
if ((result = request_irq (dev->irq,&cirrus_interrupt,0,dev->name,dev)) < 0) {
printk (KERN_ERR "%s: could not register interrupt %d/n",dev->name,dev->irq);
return (result);
}
else
printk (KERN_ERR "%s: register interrupt %d/n",dev->name,dev->irq);
#if defined(CONFIG_ARCH_CSB226)
set_irq_type(dev->irq, IRQT_RISING);//设置为上升中断模式
#endif
/* enable the ethernet controller */
cirrus_set (dev,PP_RxCFG,RxOKiE | BufferCRC | CRCerroriE | RuntiE | ExtradataiE);
cirrus_set (dev,PP_RxCTL,RxOKA | IndividualA | BroadcastA);
cirrus_set (dev,PP_TxCFG,TxOKiE | Out_of_windowiE | JabberiE);
cirrus_set (dev,PP_BufCFG,Rdy4TxiE | RxMissiE | TxUnderruniE | TxColOvfiE | MissOvfloiE);
cirrus_set (dev,PP_LineCTL,SerRxON | SerTxON);
cirrus_set (dev,PP_BusCTL,EnableRQ);
#ifdef FULL_DUPLEX
cirrus_set (dev,PP_TestCTL,FDX);
#endif /* #ifdef FULL_DUPLEX */
/* start the queue */
netif_start_queue (dev);
MOD_INC_USE_COUNT;
return (0);
}
static int cirrus_stop (struct net_device *dev)
{
/* disable ethernet controller */
cirrus_write (dev,PP_BusCTL,0);
cirrus_write (dev,PP_TestCTL,0);
cirrus_write (dev,PP_SelfCTL,0);
cirrus_write (dev,PP_LineCTL,0);
cirrus_write (dev,PP_BufCFG,0);
cirrus_write (dev,PP_TxCFG,0);
cirrus_write (dev,PP_RxCTL,0);
cirrus_write (dev,PP_RxCFG,0);
/* uninstall interrupt handler */
free_irq (dev->irq,dev);
/* stop the queue */
netif_stop_queue (dev);
MOD_DEC_USE_COUNT;
return (0);
}
static int cirrus_set_mac_address (struct net_device *dev, void *p)//设置MAC码
{
struct sockaddr *addr = (struct sockaddr *)p;
int i;
if (netif_running(dev))
return -EBUSY;
memcpy(dev->dev_addr, addr->sa_data, dev->addr_len);
/* configure MAC address */
for (i = 0; i < ETH_ALEN; i += 2)
cirrus_write (dev,PP_IA + i,dev->dev_addr[i] | (dev->dev_addr[i + 1] << 8));
return 0;
}
static struct net_device_stats *cirrus_get_stats (struct net_device *dev)//查看信息
{
cirrus_t *priv = (cirrus_t *) dev->priv;
return (&priv->stats);
}
static void cirrus_set_receive_mode (struct net_device *dev)//设置接受模式
{
if ((dev->flags & IFF_PROMISC))
cirrus_set (dev,PP_RxCTL,PromiscuousA);
else
cirrus_clear (dev,PP_RxCTL,PromiscuousA);
if ((dev->flags & IFF_ALLMULTI) && dev->mc_list)
cirrus_set (dev,PP_RxCTL,MulticastA);
else
cirrus_clear (dev,PP_RxCTL,MulticastA);
}
static int cirrus_eeprom_wait (struct net_device *dev)
{
int i;
for (i = 0; i < 200; i++) {
if (!(cirrus_read (dev,PP_SelfST) & SIBUSY))
return (0);
udelay (1);
}
return (-1);
}
static int cirrus_eeprom_read (struct net_device *dev,u16 *value,u16 offset)
{
if (cirrus_eeprom_wait (dev) < 0)
return (-1);
cirrus_write (dev,PP_EEPROMCommand,offset | EEReadRegister);
if (cirrus_eeprom_wait (dev) < 0)
return (-1);
*value = cirrus_read (dev,PP_EEPROMData);
return (0);
}
static int cirrus_eeprom (struct net_device *dev,cirrus_eeprom_t *eeprom)
{
u16 offset,buf[16],*word;
u8 checksum = 0,*byte;
if (cirrus_eeprom_read (dev,buf,0) < 0) {
read_timed_out:
printk (KERN_DEBUG "%s: EEPROM read timed out/n",dev->name);
return (-ETIMEDOUT);
}
if ((buf[0] >> 8) != 0xa1) {
printk (KERN_DEBUG "%s: No EEPROM present/n",dev->name);
return (-ENODEV);
}
if ((buf[0] & 0xff) < sizeof (buf)) {
eeprom_too_small:
printk (KERN_DEBUG "%s: EEPROM too small/n",dev->name);
return (-ENODEV);
}
for (offset = 1; offset < (buf[0] & 0xff); offset++) {
if (cirrus_eeprom_read (dev,buf + offset,offset) < 0)
goto read_timed_out;
if (buf[offset] == 0xffff)
goto eeprom_too_small;
}
if (buf[1] != 0x2020) {
printk (KERN_DEBUG "%s: Group Header #1 mismatch/n",dev->name);
return (-EIO);
}
if (buf[5] != 0x502c) {
printk (KERN_DEBUG "%s: Group Header #2 mismatch/n",dev->name);
return (-EIO);
}
if (buf[12] != 0x2158) {
printk (KERN_DEBUG "%s: Group Header #3 mismatch/n",dev->name);
return (-EIO);
}
eeprom->io_base = buf[2];
eeprom->irq = buf[3];
eeprom->dma = buf[4];
eeprom->mem_base = (buf[7] << 16) | buf[6];
eeprom->rom_base = (buf[9] << 16) | buf[8];
eeprom->rom_mask = (buf[11] << 16) | buf[10];
word = (u16 *) eeprom->mac;
for (offset = 0; offset < 3; offset++) word[offset] = buf[13 + offset];
byte = (u8 *) buf;
for (offset = 0; offset < sizeof (buf); offset++) checksum += byte[offset];
if (cirrus_eeprom_read (dev,&offset,0x10) < 0)
goto read_timed_out;
if ((offset >> 8) != (u8) (0x100 - checksum)) {
printk (KERN_DEBUG "%s: Checksum mismatch (expected 0x%.2x, got 0x%.2x instead/n",
dev->name,
(u8) (0x100 - checksum),
offset >> 8);
return (-EIO);
}
return (0);
}
/*
* Architecture dependant code
*/
#ifdef CONFIG_SA1100_FRODO
static void frodo_reset (struct net_device *dev)
{
int i;
volatile u16 value;
/* reset ethernet controller */
FRODO_CPLD_ETHERNET |= FRODO_ETH_RESET;
mdelay (50);
FRODO_CPLD_ETHERNET &= ~FRODO_ETH_RESET;
mdelay (50);
/* we tied SBHE to CHIPSEL, so each memory access ensure the chip is in 16-bit mode */
for (i = 0; i < 3; i++) value = cirrus_read (dev,0);
/* FIXME: poll status bit */
}
#endif /* #ifdef CONFIG_SA1100_FRODO */
/*
* Driver initialization routines
*/
void __init reset_chip(struct net_device *dev)//复位芯片
{
int reset_start_time;
cirrus_write(dev, PP_SelfCTL, cirrus_read(dev, PP_SelfCTL) | RESET);
/* wait 30 ms */
current->state = TASK_INTERRUPTIBLE;
schedule_timeout(30*HZ/1000);
/* Wait until the chip is reset */
reset_start_time = jiffies;
while( (cirrus_read(dev, PP_SelfST) & INITD) == 0 &&
jiffies - reset_start_time < 4)
;
}
static int io = 0;
static int irq = 0;
int __init cirrus_probe (struct net_device *dev)//探测函数
{
static cirrus_t priv;
int i,result;
u16 value;
cirrus_eeprom_t eeprom;
printk ("Cirrus Logic CS8900A driver for Linux (V0.02)/n");
memset (&priv,0,sizeof (cirrus_t));
ether_setup (dev);//初始化公共成员
//
dev->open = cirrus_start;
dev->stop = cirrus_stop;
dev->hard_start_xmit = cirrus_send_start;//启动发送队列
dev->get_stats = cirrus_get_stats;
dev->set_multicast_list = cirrus_set_receive_mode;
dev->set_mac_address = cirrus_set_mac_address;
dev->tx_timeout = cirrus_transmit_timeout;//超时处理
dev->watchdog_timeo = HZ;//发送最大时间1ms
/* hack!! */ // 00:05:5D:DD:81:18
dev->dev_addr[0] = 0x00;
dev->dev_addr[1] = 0x00;
dev->dev_addr[2] = 0x02;
dev->dev_addr[3] = 0x50;
dev->dev_addr[4] = 0x10;
dev->dev_addr[5] = 0x08;//mac码
dev->if_port = IF_PORT_10BASET;//选择rj45
dev->priv = (void *) &priv;
SET_MODULE_OWNER (dev);
dev->base_addr = CIRRUS_IOADDR;
dev->irq = CIRRUS_IRQ;
if (io > 0) dev->base_addr = io;
if (irq > 0) dev->irq = irq;
///初始化私有数据结构
if (!dev->base_addr) {//虚拟地址出错
printk (KERN_ERR
"%s: No default I/O base address defined. Use io=... or/n"
"%s: define CIRRUS_DEFAULT_IO for your platform/n",
dev->name,dev->name);
return (-EINVAL);
}
if (!dev->irq) {
printk (KERN_ERR
"%s: No default IRQ number defined. Use irq=... or/n"
"%s: define CIRRUS_DEFAULT_IRQ for your platform/n",
dev->name,dev->name);
return (-EINVAL);
}
if (!request_region (dev->base_addr,16,dev->name)) {//工作在IO模式时共有16个寄存器申请为IO端口
printk (KERN_ERR "%s: can't get I/O port address 0x%lx/n",dev->name,dev->base_addr);
return -EBUSY;
}
#ifdef CONFIG_SA1100_FRODO
frodo_reset (dev);
#endif /* #ifdef CONFIG_SA1100_FRODO */
if (!cirrus_eeprom (dev,&eeprom))//使用片外EEPRAM保存MAC
for (i = 0; i < 6; i++)
dev->dev_addr[i] = eeprom.mac[i];
//number for Crystal Semiconductor
if ((value = cirrus_read (dev,PP_ProductID)) != EISA_REG_CODE) {
printk (KERN_ERR "%s: incorrect signature 0x%.4x/n",dev->name,value);
return (-ENXIO);
}
/* verify chip version */
value = cirrus_read (dev,PP_ProductID + 2);
if (VERSION (value) != CS8900A) {//是否为A版本芯片
printk (KERN_ERR "%s: unknown chip version 0x%.8x/n",dev->name,VERSION (value));
return (-ENXIO);
}
printk (KERN_INFO "%s: CS8900A rev %c detected/n",dev->name,'B' + REVISION (value) - REV_B);
reset_chip(dev);//复位
cirrus_write (dev,PP_IntNum,0);//使用0中断引脚
for (i = 0; i < ETH_ALEN; i += 2)//将MAC码配置到Individual Address寄存器
cirrus_write (dev,PP_IA + i,dev->dev_addr[i] | (dev->dev_addr[i + 1] << 8));
return (0);
}
EXPORT_NO_SYMBOLS;
static struct net_device dev;//如此初始化？
static int __init cirrus_init (void)
{
unsigned long extint1;
extint1 = __raw_readl(S3C2410_EXTINT1);
extint1 &= ~(7<<4);
extint1 |= (4<<4);
__raw_writel(extint1, S3C2410_EXTINT1);//设置EIN9为上升沿中断
memset (&dev,0,sizeof (struct net_device));//网络结构体初始化
dev.init = cirrus_probe;//硬件初始化函数
return (register_netdev (&dev));//注册网络设备
}
static void __exit cirrus_cleanup (void)
{
release_region (dev.base_addr,16);
unregister_netdev (&dev);
}
MODULE_AUTHOR ("Abraham van der Merwe <abraham@2d3d.co.za>");
MODULE_DESCRIPTION ("Cirrus Logic CS8900A driver for Linux (V0.02)");
MODULE_LICENSE ("GPL");
MODULE_PARM_DESC (io,"I/O Base Address");
MODULE_PARM (io,"i");
MODULE_PARM_DESC (irq,"IRQ Number");
MODULE_PARM (irq,"i");
module_init (cirrus_init);
module_exit (cirrus_cleanup);
验证步骤：
1.将开发板和PC用交叉网线连接，将两者的IP地址设为同一局域网段后互ping对方，都可以正常ping通；
2.TCP/IP程序的service--client服务测试，将service上传到开发板运行再运行client均可以发送和接收。
应用测试程序如下：
#include <stdio.h>
#include <sys/socket.h>
#include <unistd.h>
#include <sys/types.h>
#include <netinet/in.h>
#include <stdlib.h>
#include <time.h>
#define SERVER_PORT 12345 // define the defualt connect port id
#define LENGTH_OF_LISTEN_QUEUE 10 //length of listen queue in server
#define BUFFER_SIZE 255
#define WELCOME_MESSAGE "welcome to connect the server. "
int main(int argc, char **argv)
{
printf("The beginning of main function./n");
int servfd,clifd;
struct sockaddr_in servaddr,cliaddr;
if ((servfd = socket(AF_INET,SOCK_STREAM,0)) < 0)//建立套接字----AF_INET为IPv4协议 SOCK_STREAM:字节流套接字socket（它使用 TCP 协议）
{
printf("create socket error!/n");
exit(1);
}
bzero(&servaddr,sizeof(servaddr));
servaddr.sin_family = AF_INET;
servaddr.sin_port = htons(SERVER_PORT);//将16bit端口号换成网络字符顺序--端口号用s，ip地址用l
servaddr.sin_addr.s_addr = htonl(INADDR_ANY);//ip地址可以以后配置
//将32bit IP地址换成网络字符顺序 #define INADDR_ANY (u_int32_t)0x00000000
if (bind(servfd,(struct sockaddr*)&servaddr,sizeof(servaddr))<0)//将本地IP地址绑定端口号
{
printf("bind to port %d failure!/n",SERVER_PORT);
exit(1);
}
if (listen(servfd,LENGTH_OF_LISTEN_QUEUE) < 0)//服务器等待客户端的连接请求
{
printf("call listen failure!/n");
exit(1);
}
while(1){
printf("The beginning of the circle./n");
char buf[BUFFER_SIZE];
long timestamp;
socklen_t length = sizeof(cliaddr);
printf("before accept function ./n");
clifd = accept(servfd,(struct sockaddr*)&cliaddr,&length);//accept用于等待客户端的数据包到来（是阻塞函数）
printf("after accept function./n");
if (clifd < 0){
printf("error comes when call accept!/n");
return 1;
}
strcpy(buf,WELCOME_MESSAGE);
//inet_ntop(INET_ADDRSTRLEN,cliaddr.sin_addr,buf,BUFFER_SIZE);
printf("from client,IP:%s,Port:%d/n",inet_ntoa(cliaddr.sin_addr),ntohs(cliaddr.sin_port));//打印客户端IP地址和端口号
timestamp = time(NULL);
strcat(buf,"timestamp in server:");
strcat(buf,ctime(×tamp));//字符连接之后为"welcome to connect the server.timestamp in server: time"
send(clifd,buf,BUFFER_SIZE,0);//发送客户端
close(clifd);
}
close(servfd);
return 0;
}//服务端程序
#include <stdio.h>
#include <sys/socket.h>
#include <unistd.h>
#include <sys/types.h>
#include <netinet/in.h>
#include <stdlib.h>
#define SERVER_PORT 12345 // define the defualt connect port id
#define CLIENT_PORT 12345 // define the defualt client port as a random port
#define BUFFER_SIZE 255
#define REUQEST_MESSAGE "welcome to connect the server./n"
int main(int argc, char **argv)
{
int servfd,clifd,length = 0;
struct sockaddr_in servaddr,cliaddr;
socklen_t socklen = sizeof(servaddr);
char buf[BUFFER_SIZE];
while(1){
if ((clifd = socket(AF_INET,SOCK_STREAM,0)) < 0)
{
printf("create socket error!/n");
exit(1);
}
srand(time(NULL));//获得当前的时间作为随机数的种子
bzero(&cliaddr,sizeof(cliaddr));
cliaddr.sin_family = AF_INET;
cliaddr.sin_port = htons(CLIENT_PORT);
cliaddr.sin_addr.s_addr = htonl(INADDR_ANY);//客户端IP地址可以配置
servaddr.sin_family = AF_INET;
inet_aton("192.168.10.100",&servaddr.sin_addr);//指定要连接的服务端IP地址
servaddr.sin_port = htons(SERVER_PORT);
if (connect(clifd,(struct sockaddr*)&servaddr, socklen) < 0) {//用于client端与服务器端建立连接
printf("can't connect to %s!/n",argv[1]);
exit(1);
}
length = recv(clifd,buf,BUFFER_SIZE,0);//接收服务端数据
if (length < 0)
{
printf("error comes when recieve data from server %s!",argv[1]);
exit(1);
}
printf("from server %s :/n/t%s ",argv[1],buf);
close(clifd);
}
return 0;
}//客户端程序
扫一扫
3840
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
