Chinaunix首页 | 论坛 | 博客
  • 博客访问: 350763
  • 博文数量: 112
  • 博客积分: 5245
  • 博客等级: 大校
  • 技术积分: 1120
  • 用 户 组: 普通用户
  • 注册时间: 2007-11-07 09:20
个人简介

静下来,定好方向,好好干。

文章分类
文章存档

2017年(1)

2012年(1)

2011年(5)

2010年(6)

2009年(16)

2008年(59)

2007年(24)

我的朋友

分类: LINUX

2007-11-11 10:08:38


网络的一些相关知识:
网卡功能: 载波侦听, 冲突检测, 随机延时等待;
网线一般不得超过100米;  
交换机的功能: 动态建立连接桥梁, 探知端口上有几台电脑, 自学习;
远距离传送: 铜线 + 中继器/光纤/微波 等    挑战在于:如何传更远, 更快, 减少错误;
局域网物理层的功能目标: 更准, 更快, 如何避免冲突;
链路, 就是连接相邻两台电脑的线路; 如何可靠的传输, 通过校验, 不是绝对安全, 但已经足够;
protocol是用来定义数据桢格式, 交互顺序的.   比如以太网802.1, 广域网ppp
? 流控制, 应答, "滑动窗口协议"
点到点保证可靠传送, 端到端可靠吗? 由于当中如果缺少整桢数据, 端到端并不可靠.
路由协议是用于路由器之间维护路由表的协议:
每个路由的下一跳要明确;   定期广播;   启动时广播;
以太网是当前应用最普遍的局域网技术;
mac地址在局域网内不重复, 但在不同的局域网可能重复;
socket = Sip + Sport +Tip +Tport   唯一确定一条网络通路;
HTTP请求格式:
telnet 80
GET / HTTP/1.1 \n
HOST: \n\n
如何软件手段获取域名的IP地址?   如何提取网页的特定信息?
linux中看路由: traceroute + webname
xp中看路由:       tracert + webname


TCP/IP协议族层次,由上往下:   应用层->传输层->网络层->链路层
OSI参考模型7层, 由上往下:   应用层, 表示层, 会话层->传输层->网络层->数据链路层, 物理层
应用层协议:
FTP   file transfer protocol, 允许用户以文件操作的方式与另一主机通信;
SMTP   simple mail transfer protocol, 为系统间传送电子邮件;
TELNET   telnet terminal protocol, 允许用户以虚终端方式访问远程主机;
HTTP   hypertext transfer protocol, 环球www的基础;
TFTP   trivial file transfer protocol, ftp的简化版本, 基于UDP协议;

传输层协议:
TCP   transmission control protocol, 一种提供给用户进程的可靠的全双工的字节流面向连接的协议.
UDP   user datagram protocol, 一种提供给用户进程的无连接的协议, 不执行正确性检查.

网络层协议:
IP   internet protocol, 负责主机间数据路由和网络上数据的存储, 同时为ICMP, TCP, UDP提供分组发送服务;
ARP   address resolution protocol, 此协议将网络地址映射到硬件地址;
RARP   reverse address resolution protocol, 此协议将硬件地址映射到网络地址;
ICMP   internet control message protocol, 此协议处理信关和主机间的差错和传送控制; 本身也是IP的一部分;

IP地址, 32bit, 4字节, 通常采用点分十进制记法: 192.168.0.1 ; Dotted decimal string representation;
特殊的IP地址:   255.255.255.255   网络内广播,路由器不转发;

子网掩码, 表明了该IP所在网络的地址范围;

路由表, 路由, 路由节点, 接口, 条目, 缺省路由条目;
路由:   数据报从源地址到目的地址所经过的道路, 由一系列路由节点的地址构成.

小端存储, 0x01020304, 后面的是小地址;
大端存储, 0x01020304, 前面的是小地址;   网络数据就是大端格式;
i386是小端存储, 一些大端存储的CPU有POWER PC, SUNSPARC.
转换函数:  
uint16_t htons(uint16_t value);   //s代表short
uint32_t htonl(uint32_t value);   //l代表long
返回网络顺序的值;
uint16_t ntohs(uint16_t value);
uint32_t ntohs(uint32_t value);
返回主机顺序的值;

其他常用函数:
void bzero(void *dest, size_t nbytes);
void bcopy(const void *src, void *dest, size_t nbytes);
void bcmp(const void *ptr1, const void *ptr2, size_t nbytes);
void *memset(void *dest, int c, size_t len);
void *memcpy(void *dest, const void *src, size_t nbytes);
int memcmp(const void *ptr1, const void *ptr2, size_t nbytes);

地址转换:
点分十进制字符串   --inet_aton -->网络顺序32位整形值
162.105.129.7               <--inet_ntoa --0x 07  81  69  A2   (这是i386主机上打印出的值)
int inet_aton( const char *strptr, struct in_addr *addrptr);   地址有效返回非0, 无效返回0;
char *inet_ntoa( struct in_addr inaddr);   返回数据存在static memory中.
struct in_addr{
       in_addr_t s_addr;
}
typedef u_int32_t in_addr_t;

inet_pton 和 inet_ntop较新, 可以处理ipv4, ipv6两种地址;   p->presentation   n->numeric
#include
int inet_pton( int family, const char *strptr, void *addrptr);   有效地址返回1, 无效返回0, 出错返回-1;
const char *inet_ntop( int family, const void *addrptr, char *strptr, size_t len);
成功返回结果指针, 出错返回NULL;
family   可以是AF_INET, AF_INET6
len   的定义如下:
#include
#define INET_ADDRSTRLEN   16   /*for ipv4 dotted-decimal */
#define INET6_ADDRSTRLEN   46   /*for ipv6 hex string */

socket是编程接口, 是一系列函数调用;   一对socket构成了交流数据的一个通道; 一个进程可以有多个socket;
#include
#include
int socket (int domain, int type, int protocol);   //成功返回一个非负的描述符, 出错返回-1;
    domain                    description
    AF_INET                  Ipv4 protocols
    AF_INET6                Ipv6 protocols
    AF_UNIX                  Unix domain protocols
    AF_UNSPEC              Unspecified

    type                        description
    SOCK_STREAM         stream socket
    SOCK_DGRAM           datagram socket
    SOCK_RAW               raw socket

    protocol:                 0

#include
#include
int bind( int  sockfd, struct sockaddr *my_addr, socklen_t addlen);    //成功返回0, 出错返回-1;
struct sockaddr{
       sa_family_t sa_family;
       char                sa_data[14];
}
struct sockaddr_in{
       sa_family_t   sin_family;
       in_port_t       sin_port;      //2bytes
       struct in_addr sin_addr;   //4bytes
       char                   sin_zero[8];
}
这两个结构体指针可以互相强制转换;
地址值可以是INADDR_ANY通配地址, 也可以是本地ip地址.
本地可以有多个IP地址, 一旦绑定, 此socket上发送的数据以此地址为IP源地址;
端口可以分配一个非0, 也可以是0, 此时系统会分配一个非0值;
客户端通常不指定本地IP, 系统根据目的地址选择要使用的网卡, 然后用该网卡的地址作为源地址;
服务器, 一般设为INADDR_ANY, 由系统挑选一地址, 该地址是客户端连接请求是确定的;
客户端通常不需要bind, 服务器需要bind以表明使用的端口;

#include
int listen( int sockfd, int backlog);   //成功返回0, 出错返回-1;
该函数使socket在协议地址上监听, 并为该socket建立一个连接队列, 保存到达的服务请求, 直到程序处理;
backlog   指定在请求队列中允许的最大请求数, 进入的连接请求将在队列中等待被accept. 多数系统缺省20;
如果队列已满, 新来的请求将被拒绝, 客户收到一个出错信息;

#include
#include
int accept( int sockfd, struct sockaddr *addr, socklen_t *addrlen);   //成功返回非负的连接描述符, 出错-1;
用listen建立好输入队列后, 服务器可以调用accept阻塞式的等待客户的连接请求;
连接成功后往返回的连接描述符来读写数据;   sockfd继续用于监听连接请求;
addr   用来存放客户端主机的信息;

#include
#include
int connect( int sockfd, const struct sockaddr *serv_addr, socklen_t addrlen);   //成功返回0, 出错-1;
用于客户端向服务器发出连接请求, 成功后可以用sockfd来读写数据;
serv_addr   是包含远端主机IP地址和端口号的指针;
出错返回-1, 并设置errno, 常见如下:
    ETIMEOUT   连接超时;
    ECONNREFUSED   服务器不在listen;
    ENETUNREACH   网络不通
常用于TCP客户端, 服务器一般不主动去连;
在UDP应用中, 也可以用connect, 目的是建立双方的ip-port对, 可直接使用read, write, 无需在sendto中指定;

#include
int read( socketfd, void *buf, size_t n);   //成功返回读取的字节数, 出错返回-1;
int write(socketfd, void *buf, size_t n);   //成功返回写入的字节数, 出错返回-1;
对于read, 如果读出的数目小于n, 可能是接近文件结尾, 从终端读, 被信号中断等原因;
如果还没开始读, 就被信号打断, 此时返回-1, 并置errno为EINTR.
对于write, 如果还没开始写, 就被信号打断, 此时返回-1, 并置errno为EINTR.

#include
#include int recv(int sockfd, void *buf, int len, int flags);
int send(int sockfd, void *buf, int len, int flags);
这2个函数比read, write多了个flags控制参数:
 flags description  recv  send 
 MSG_DONTROUTE  bypass routing table lookup
 
 MSG_DONTWAIT  only this operation is nonblocking
 *  *
 MSG_OOB  send or receive out-of-band data
 *  *
 MSG_PEEK  peek at incoming message
 *  
 MSG_WAITALL wait for all the data   *  

#include
int close( int fd);    //成功返回0, 出错返回-1;
用于TCP时, 如果发送队列非空, 发送之, 然后终止TCP连接;

#include
#include
int recvfrom( int sockfd, void *buf, size_t len, int flags, struct sockaddr *from, socklen_t *fromlen);
int sendto( int sockfd, const void *msg, size_t len, int flags, const struct sockaddr *to, socklen_t tolen);
这两个函数比recv, send这两个函数多了后2个地址参数;包含了IP地址和端口信息; 都可以用在TCP, UDP情况;
from是等待被填写的消息的源地址及端口, to是填好的目的地址及端口;

可设置socket为非阻塞型:
#include
#include
int fcntl( int fd, int cmd);

int save_flags;
save_flags = fcntl(socket_fd, F_GETFL);   //获得当前状态
save_flags | = O_NONBLOCK;
fcntl( socket_fd, F_SETFL, save_flags);   //设置指定的新状态

设置为非阻塞后:
对于read, recv, recvfrom   如果没有可用的信息, 返回-1, errno设为EAGAIN;
对于write, send, sendto     如果消息无法放入buffer, 返回-1, errno设为EAGAIN;
对于accept   如果不行, 返回-1, errno设为EAGAIN;
对于connect, 如果不行, 返回-1, errno设为EINPROGRESS;

select及其相关函数:   
//according to POSIX 1003.1-2001.
#include      
//according to earlier standards.
#include         
#include
#include

int select(int maxfdpl, fd_set *readfds, fd_set *writefds, fd_set *exceptfds, struct timeval *timeout);
成功返回所有sets中描述符的个数, 超时返回0, 出错返回-1;
检查readfds中带1的位, 若有数据可读, 1保留, 否则清零;
检查writefds中带1的位, 若写不被阻塞, 表示可写, 1保留, 否则清零;
最后返回剩下的累计readfds, writefds, exceptfds当中1的总数;

四个宏用于fd_set操作:
FD_CLR(int fd, fd_set *set);         //用来对set删除fd;
FD_ISSET(int fd, fd_set *set);      //指示fd是不是已经是set的一部分;
FD_SET(int fd, fd_set *set);      //对set添加fd;
FD_ZERO(fd_set *set);      //清空set;

timeout是从调用开始到select返回前, 会经历的最大等待时间;
如果为0, 会立即返回;   如果为NULL, 会阻塞式等待;
在linux中, select函数会改变timeout值, 指示还剩下的时间, 所以, 最好在循环里要重新给timeout赋值;
struct timeval{
       long   tv_sec;      //seconds
       long   tv_usec;   //microseconds
}

#include
signal(SIGPIPE, SIG_IGN)      忽略SIGPIPE信号, 此处没用sigaction函数;
如果服务端已经关闭, client继续给这个连接发送内容, 第一次写, 根据TCP协议, 会收到RST响应, 如果还要写, 系统会发送个SIGPIPE信号给进程, 该信号的默认反应是关闭进程; 在此忽略.

如果用^C把server终止掉, 由于client端没有执行close来关闭连接, 连接还会等待client的FIN包一段时间, 如果用netstat -a查看, 发现有FIN_WAIT2状态存在, 这说明目前有socket在此地址上使用, 再次bind失败.
解决办法是: 使用setsockopt, 使这个socket可以被重用地址, 在soket调用和bind之间加上这一段:
int opt=1;
setsockopt( listen_fd, SOL_SOCKET, SO_REUSEADDR, &opt, sizeof(opt));

#define offset( TYPE, MEMBER )         ( ( int ) &( ( TYPE * ) 0 ) ->MEMBER)
该宏用来获取结构体成员的偏移量;

服务端bind不是必须的, 它是要告诉操作系统, 某个socket使用某个地址和端口, 如果不指定, 系统会分配一个.
UDP客户端也能使用connect,  然后也可以使用无地址信息的读写函数了, 如:read, write, send, recv等.
服务端的程序可以有几种方案: 多进程, 多线程, select,

总而言之:
对于server, 步骤如下:
    配置本地要监听的sin地址->socket得到listen_fd->
    把listen_fd监听描述符bind到sin上->设置listen开始监听->
    acept阻塞等待, 得到conn_fd用于读写, 得到pin的被填充的内容保存客户端信息->
    对conn_fd进行read, write操作->与某客户端连接结束后close(conn_fd)->
    整个服务程序结束时close(listen_fd);
对于client, 步骤如下:
    配置目标地址pin->socket得到sock_fd->
    用sock_fd去connect目标地址pin, 若成功返回则可开始用sock_fd进行read, write操作->
    结束后close(sock_fd);

一些关于socket的例程:
//判断大小端的方法:
uion{
    int s;
    char c[4];
}un;
un.s = 0x01020304
if (un.c[0] == 1)
    printf("big-endian\n");
if (un.c[0] == 4)
    printf("little-endian\n");
else
    printf("unknow\n");

/*client.c 
*a simple client program
*/

#include
#include
#include
#include
#include
#include
#include
#define MAXLINE 80
int port = 8000;

int main(int argc, char *argv[])
{
     struct sockaddr_in pin;
     char buf[MAXLINE];
     int sock_fd;
     char *str = "A default test string";

     if (argc > 1)
          str = argv[1];

     bzero(&pin, sizeof(pin));
     pin.sin_family = AF_INET;
     inet_pton(AF_INET, "127.0.0.1", &pin.sin_addr);
     pin.sin_port = htons(port);

     sock_fd = socket(AF_INET, SOCK_STREAM, 0);
     connect(sock_fd, (void*)&pin, sizeof(pin));
     write(sock_fd, str, strlen(str) + 1);
     read(sock_fd, buf, MAXLINE);
     printf("Response from server:%s\n", buf);
     close(sock_fd);
    
     return 0;
}

/*server.c
*a simple server program
*/

#include
#include
#include
#include
#include
#include
#include
#define MAXLINE 80
int port = 8000;

int main(void)
{
     struct sockaddr_in sin;
     struct sockaddr_in pin;
     int listen_fd;
     int conn_fd;
     int address_size = sizeof(pin);
     char buf[MAXLINE];
     char str[INET_ADDRSTRLEN];
     int i;
     int len;

     bzero(&sin, sizeof(sin));
     sin.sin_family = AF_INET;
     sin.sin_addr.s_addr = INADDR_ANY;
     sin.sin_port = htons(port);

     listen_fd = socket(AF_INET, SOCK_STREAM, 0);
     bind(listen_fd, (struct sockaddr *)&sin, sizeof(sin));
     listen(listen_fd, 20);
     printf("Accepting connections ...\n");

     while(1)
     {
          conn_fd = accept(listen_fd,
                    (struct sockaddr *)&pin, &address_size);
          read(conn_fd, buf, MAXLINE);

          printf("received from client %s at port %d: %s\n",
                    inet_ntop(AF_INET, &pin.sin_addr, str,
                         sizeof(str)), ntohs(pin.sin_port), buf);
         
          //just convert the characters to upper case
          len = strlen(buf);
          for (i=0; i               buf[i] = toupper(buf[i]);
          write(conn_fd, buf, len+1);
          close(conn_fd);
     }

     return 0;
}
    

/*client.c
*socket client with error detect
* and sockopt
*/

#include
#include
#include
#include
#include
#include
#include
#include
#include
#define MAXLINE 80
int port = 8000;

int main(int argc, char *argv[])
{
     struct sockaddr_in pin;
     char buf[MAXLINE];
     int sock_fd;
     char str[MAXLINE];
     char *myip = "127.0.0.1";
     int n;

     if (argc > 1)
     {
          myip = argv[1];
     }

     bzero(&pin, sizeof(pin));
     pin.sin_family = AF_INET;
     inet_pton(AF_INET, myip, &pin.sin_addr);
     pin.sin_port = htons(port);

     sock_fd = socket(AF_INET, SOCK_STREAM, 0);
     if (sock_fd == -1)
     {
          perror("call to socket");
          exit(1);
     }

     n = connect(sock_fd, (void*)&pin, sizeof(pin));
     if (n == -1)
     {
          perror("call to connect");
          exit(1);
     }

     while (fgets(str, MAXLINE, stdin) != NULL)
     {
     writeagain:
          n = write(sock_fd, str, strlen(str) + 1);
         
          if (n == -1)
          {
               if (errno == EINTR)
                    goto writeagain;
               else
               {
                    printf("call to write");
                    exit(1);
               }
          }
     readagain:
          n = read(sock_fd, buf, MAXLINE);
         
          if (n == -1)
          {
               if (errno == EINTR)
                    goto readagain;
               else
               {
                    perror("call to read");
                    exit(1);
               }
          }else if (n == 0)
          {
               printf ("the other side has been closed.\n");
               close(sock_fd);
          }         
          printf("Response from server:%s\n", buf);
          /*
          if (n == 0)
               printf("the other side has been closed.\n");
          else
               printf("Response from server:%s\n", buf);
          */
          if (strncmp(str, "bye", 3) == 0)
               break;
     }
     sleep(1);
     n = close(sock_fd);
     if (n == -1)
     {
          perror("call to close");
          exit(1);
     }
    
     return 0;
}

/**
#########################################################
#         Filename:     server.c
#         Description:  select server
#########################################################
**/


#include
#include
#include
#include
#include
#include
#include
#include
#include
#include

#define MAXLINE 80
int port = 8000;

int main (void)
{
  struct sockaddr_in sin;
  struct sockaddr_in pin;
  int listen_fd;
  int conn_fd;
  int sock_fd;
  int nready;
  int client[FD_SETSIZE];
  int maxi;
  int maxfd;
  fd_set rset;
  fd_set allset;

  int address_size;
  char buf[MAXLINE];
  char str[INET_ADDRSTRLEN];    // 16
  int i;
  int len;
  int n;

  bzero (&sin, sizeof (sin));
  sin.sin_family = AF_INET;
  sin.sin_addr.s_addr = INADDR_ANY;
  sin.sin_port = htons (port);


  listen_fd = socket (AF_INET, SOCK_STREAM, 0);

  if (listen_fd == -1)
    {
      perror ("call to socket");
      exit (1);
    }

  {
    int opt = 1;
    setsockopt (listen_fd, SOL_SOCKET, SO_REUSEADDR, &opt, sizeof (opt));
  }
  n = bind (listen_fd, (struct sockaddr *) &sin, sizeof (sin));
  if (n == -1)
    {
      perror ("call to bind");
      exit (1);
    }

  n = listen (listen_fd, 20);
  if (n == -1)
    {
      perror ("call to listen");
      exit (1);
    }
  printf ("Accepting connections...\n");

  maxfd = listen_fd;
  maxi = -1;
  for (i = 0; i < FD_SETSIZE; i++)
    client[i] = -1;
  FD_ZERO (&allset);
  FD_SET (listen_fd, &allset);

  for (;;)
    {
      rset = allset;
      nready = select (maxfd + 1, &rset, NULL, NULL, NULL);
      if (FD_ISSET (listen_fd, &rset))
    {
      address_size = sizeof (pin);
      conn_fd =
      accept (listen_fd, (struct sockaddr *) &pin, &address_size);
      for (i = 0; i < FD_SETSIZE; i++)
        {
          if (client[i] < 0)
        client[i] = conn_fd;
          break;
        }
      if (i == FD_SETSIZE)
        {
          printf ("too many clients");
          exit (1);
        }
      printf ("new client: %s, port %d\n",
          inet_ntop (AF_INET, &pin.sin_addr, str, sizeof (str)),
          ntohs (pin.sin_port));

      FD_SET (conn_fd, &allset);
      if (conn_fd > maxfd)
        maxfd = conn_fd;
      if (i > maxi)
        maxi = i;
      if (--nready <= 0)
        continue;
    }
     
      for (i = 0; i <= maxi; i++)
    {
      if ((sock_fd = client[i]) < 0)
        continue;
      if (FD_ISSET (sock_fd, &rset))
        {
          n = read (sock_fd, buf, MAXLINE);
          if (n == 0)
        {
          printf ("the other side has been closed.\n");
          fflush (stdout);
          close (sock_fd);
          FD_CLR (sock_fd, &allset);
          client[i] = -1;
        }
          else
        {
          printf ("received from client %d:%s\n", i, buf);
          len = strlen (buf);
          for (i = 0; i < len; i++)
            buf[i] = toupper (buf[i]);
          write (sock_fd, buf, len + 1);
        }
          if (--nready <= 0)
        break;
        }
    }
   }
}


/*udpclient.c*/

#include
#include
#include
#include
#include
#include
#include
#include
#include
#define MAXLINE 80
int port = 8000;

int main(int argc, char *argv[])
{
     struct sockaddr_in pin;
     struct sockaddr_in rin;
     char buf[MAXLINE];
     int sock_fd;
     char str[MAXLINE];
     char sip[INET_ADDRSTRLEN];
     int n;
     int address_size;

     bzero(&pin, sizeof(pin));
     pin.sin_family = AF_INET;
     inet_pton(AF_INET, "127.0.0.1", &pin.sin_addr);
     pin.sin_port = htons(port);
     sock_fd = socket(AF_INET, SOCK_DGRAM, 0);
     if (sock_fd == -1)
     {
          perror("call to socket");
          exit(1);
     }
     while (fgets(str, MAXLINE, stdin) != NULL)
     {
          sendto(sock_fd, str, strlen(str) + 1, 0,
                    (struct sockaddr *)&pin, sizeof(pin));
          if (n == -1)
          {
               perror("call to sendto.\n");
               exit(1);
          }

          address_size = sizeof(rin);
          n = recvfrom(sock_fd, buf, MAXLINE, 0, (struct sockaddr*)
                    &rin, &address_size);
          if (n == -1)
          {
               perror("call to recvfrom.\n");
               exit(1);
          }else
          {
               printf("Response from %s port %d: %s\n",
                         inet_ntop(AF_INET, &rin.sin_addr, sip,
                              sizeof(sip)), ntohs(rin.sin_port),buf);
          }
     }
     close(sock_fd);
     if (n == -1)
     {
          perror("call to close. \n");
          exit(1);
     }
     return 0;
}

/*udpserver.c*/

#include
#include
#include
#include
#include
#include
#include
#include
#include
#define MAXLINE 80

int port =8000 ;

int main(void)
{
  struct sockaddr_in sin;
  struct sockaddr_in rin;
  int sock_fd;
  int address_size;
  char buf[MAXLINE];
  char str[INET_ADDRSTRLEN];
  int i;
  int n;
  int len;

  bzero(&sin,sizeof(sin));
  sin.sin_family=AF_INET;
  sin.sin_addr.s_addr=INADDR_ANY;
  sin.sin_port =htons(port);

  sock_fd= socket(AF_INET,SOCK_DGRAM,0);
  if(sock_fd== -1){
    perror("call to socket");
    exit(1);
  }

  n=bind(sock_fd,(struct sockaddr *) &sin,sizeof(sin));
  if(n == -1){
  perror("call to bind");
  exit(1);
  }

    while(1)
 {
     address_size=sizeof(rin);
     n =recvfrom(sock_fd,buf,MAXLINE,0,(struct sockaddr *) &rin,
      &address_size);

    if( n == -1){
  perror("call to recvfrom.\n");
  exit(1);
  }
 
    printf("received from client %s at port %d: %s\n",
      inet_ntop(AF_INET , &rin.sin_addr,str,
        sizeof(str)),ntohs(rin.sin_port),buf);

  //just convert the characters to upper case

    len =strlen(buf);
    for (i=0; i    buf[i]=toupper(buf[i]);

    n =sendto(sock_fd,buf,len +1,0,
      (struct sockaddr *) &rin,address_size);

    if( n== -1){
    perror("call to sendto.\n");
    exit(1); 
     } 
  }

}


/*unblkserver.c
*unblock socket server*/

#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#define MAXLINE 80
int port = 8000;

int main(void)
{
     struct sockaddr_in sin;
     struct sockaddr_in rin;
     int sock_fd;
     int address_size;
     char buf[MAXLINE];
     char str[INET_ADDRSTRLEN];
     int i;
     int n;
     int len;
     long flags;

     bzero(&sin, sizeof(sin));
     sin.sin_family = AF_INET;
     sin.sin_addr.s_addr = INADDR_ANY;
     sin.sin_port = htons(port);

     sock_fd = socket(AF_INET, SOCK_DGRAM, 0);
     if (sock_fd == -1)
     {
          perror("call to bind");
          exit(1);
     }
     n = bind(sock_fd, (struct sockaddr *)&sin, sizeof(sin));
     if (n == -1)
     {
          perror("call to bind");
          exit(1);
     }
    
     flags = fcntl(sock_fd, F_GETFL);
     flags |= O_NONBLOCK;
     if (fcntl(sock_fd, F_SETFL, flags) == -1)
     {
          perror("trying to set sock_fd to non-blocking");
          exit(1);
     }
     printf("sock_fd has been set to non-blocking mode.\n");
    
     while (1)
     {
          sleep(3);
          address_size = sizeof(rin);
          n = recvfrom(sock_fd, buf, MAXLINE, 0, (struct sockaddr*)
                    &rin, &address_size);
          if (n == -1 && errno != EAGAIN)
          {
               perror("call to recvfrom");
               exit(1);
          }else if (n == 0 || (n == -1 && errno == EAGAIN))
          {
               printf("no data yet\n");
               continue;
          }else
          {
               printf("received from client %s at port %d: %s\n",
                         inet_ntop(AF_INET, &rin.sin_addr, str,
                              sizeof(str)), ntohs(rin.sin_port), buf);
          }

          //just convert
          len = strlen(buf);
          for (i = 0; i < len; i++) buf[i] = toupper(buf[i]);
          n = sendto(sock_fd, buf, len+1, 0, (struct sockaddr*)
                    &rin, address_size);
          if (n == -1 && errno != EAGAIN)
          {
               perror("call to sendto");
               exit(1);
          }
     }
}


/*client80.c
*a program to get html from internet
*/

#include
#include
#include
#include
#include
#include
#include
#include
#include

#define MAXLINE 1024

int port = 80;

int main(int argc, char *argv[])
{
     FILE *fp;
     int sock_fd, ret;
     struct sockaddr_in pin;
     char buf[MAXLINE + 1];
     char *str = "GET / HTTP/1.1\n HOST:\n\n";
     char *myip = "202.108.9.31";  //

     if (argc > 1)
     {
          myip = argv[1];
     }
    
     if ((fp = fopen("163.html", "w+")) == NULL)
     {
        printf("Cannot open 163.html");
        exit(1);
     }

     bzero(&pin, sizeof(pin));
     pin.sin_family = AF_INET;
     inet_pton(AF_INET, myip, &pin.sin_addr);
     pin.sin_port = htons(port);

     sock_fd = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
     if (sock_fd == -1)
     {
          perror("call to socket");
          exit(1);
     }

     ret = connect(sock_fd, (void*)&pin, sizeof(pin));
     if (ret == -1)
     {
          perror("call to connect");
          goto PROGRAM_EXIT;
     }

WRITE_AGAIN:
     ret = write(sock_fd, str, strlen(str));
     if (ret == -1)
     {
         if (errno == EINTR)
              goto WRITE_AGAIN;
         else
             {
                 printf("call to write");
         goto PROGRAM_EXIT;
             }
     }

     /* read data from server */
     while(1)
     {
READ_AGAIN:
         ret = read(sock_fd, buf, MAXLINE);
         if (ret > 0)
         {
             buf[ret] = '\0';
             printf("Response from server:%s\n", buf);
             fprintf(fp, "%s", buf);
         }
         else if (ret == -1)
         {
             if (errno == EINTR)
                 goto READ_AGAIN;
             else
             {
                 perror("call to read");
                 goto PROGRAM_EXIT;
             }
         }
         else if (ret == 0)
         {
             printf ("the other side has been closed.\n");
             break;
         }
     }

PROGRAM_EXIT:
     close(sock_fd);
     fclose(fp);
     return 0;
}


/*domainsoc.c
*UNIX Domain Socket IPC
*/

#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include


int main(void)
{
  int fd, size;
  struct sockaddr_un un;

  un.sun_family = AF_UNIX;
  strcpy(un.sun_path, "foo.socket");
  if ((fd = socket(AF_UNIX, SOCK_STREAM, 0)) <0) {
    perror( "socket failed" );
    exit(1);
  }
  size = offsetof(struct sockaddr_un, sun_path) + strlen(un.sun_path);
  if (bind(fd, (struct sockaddr *)&un, size)< 0) {
    perror( "bind failed" );
    exit(1);
  }
  printf( "UNIX domain socket bound\n" );
  exit(0);
}

/*domainserver1.c
*UNIX Domain Socket IPC
*accept->serv_accept
*/

#include
#include
#include
#include
#include
#include

#define STALE 30

#define QLEN 10

int serv_accept(int listenfd, uid_t *uidptr)
{
  int clifd, len, err, rval;
  time_t staletime;

  struct sockaddr_un un;
  struct stat statbuf;

  len = sizeof(un);

 
  if ((clifd = accept(listenfd, (struct sockaddr *)&un, &len)) < 0)
    return (-1);

  len -= offsetof(struct sockaddr_un, sun_path);
  un.sun_path[len] = 0;

  if (stat(un.sun_path, &statbuf) <0) {
    rval = -2;
    goto errout;
  }
#ifdef S_ISSOCK
  if (S_ISSOCK(statbuf.st_mode) == 0) {
    rval = -3;
    goto errout;
  }
#endif

  if ((statbuf.st_mode & (S_IRWXG | S_IRWXO)) ||
      (statbuf.st_mode & S_IRWXU) != S_IRWXU)  {
    rval = -4;
    goto errout;
  }
  staletime = time(NULL) - STALE;
  if (statbuf.st_atime < staletime ||
      statbuf.st_ctime < staletime ||
      statbuf.st_mtime < staletime) {
    rval = -5;
    goto errout;
  }
  if(uidptr != NULL)
    *uidptr = statbuf.st_uid;
  unlink(un.sun_path);
  return(clifd);

errout:
  err = errno;
  close(clifd);
  errno = err;
  return(rval);
}

/*domainserver.c
*UNIX Domain Socket IPC
*listen->serv_listen
*/

#include
#include
#include
#include

#define QLEN 10

int serv_listen(const char *name)
{
  int fd, len, err, rval;

  struct sockaddr_un un;
 
  if ((fd = socket(AF_UNIX, SOCK_STREAM, 0)) < 0)
    return (-1);
  unlink(name);

  memset(&un, 0, sizeof(un));
  un.sun_family = AF_UNIX;
  strcpy(un.sun_path, name);
  len = offsetof(struct sockaddr_un, sun_path) + strlen(name);

  if (bind(fd, (struct sockaddr *)&un, len) <0) {
    rval = -2;
    goto errout;
  }
  if (listen(fd, QLEN) < 0) {
    rval = -3;
    goto errout;
  }
  return 0;

errout:
  err = errno;
  close(fd);
  errno = err;
  return(rval);
}

/*domainclient.c
*unix domain socket IPC
*connect->cli_conn
*/

#include
#include
#include
#include
#include
#include

#define   CLI_PATH     "/var/tmp/"     
/* +5  for    pid =14 char   */
#define   CLI_PERM     S_IRWXU          
/* rwx for user only         */




/*
 * Creat a client endpoint and connect to a server .
 * Return  fd if all OK ,<0 on error .
*/

  int cli_conn(const char *name)
{
  int    fd,len,err,rval ;
  struct sockaddr_un un;

/*creat a UNIX domain stream socket  */
    if((fd =socket( AF_UNIX,SOCK_STREAM,0 ))< 0)
    return (-1);

/* fill socket address structure with our address */
   memset(&un ,0, sizeof(un));
   un.sun_family=AF_UNIX;
   sprintf(un.sun_path,"%s%05d",CLI_PATH,getpid());
   len =offsetof(struct sockaddr_un,sun_path)+strlen(un.sun_path);

    unlink(un.sun_path);          /* in case it already exists    */
    if(bind(fd,(struct sockaddr *)&un,len)<0){
    rval =-2;
    goto errout;
}
    if(chmod(un.sun_path, CLI_PERM)< 0){
    rval = -3;
    goto errout;
    }

/* fill socket address structure with server's address */
    memset(&un,0,sizeof(un));
    un.sun_family =AF_UNIX;
    strcpy(un.sun_path,name);
    len =offsetof(struct sockaddr_un ,sun_path) +strlen(name);

  if(connect(fd, (struct sockaddr *)&un, len)<0) {
      rval =-4;
      goto errout;
  }
     return (fd);


errout:
    err = errno;
    close(fd);
    errno = err;
    return(rval);
}


信息点滴:
端口号信息可以查看/etc/services.
/etc/resolv.conf   域名服务器设置;
/etc/hosts              ? 过滤网站
ps aux |  less
netstat -a | grep :80
rpm -ivh --nodeps -force   name.rpm
/usr/share/applications   应用程序菜单所在

slash->/   period->.   comma->,
^ +.   切换全角半角中文

阅读(1306) | 评论(0) | 转发(1) |
给主人留下些什么吧!~~