socket 开发 - 那些年用过的基础 API

#include <sys/time.h>

int gettimeofday(struct timeval * tv, struct timezone * tz);

The  functions  gettimeofday() can get and set the time as well as a timezone. 
The tv argument is a struct timeval (as specified in <sys/time.h>):

    struct timeval {
        time_t      tv_sec;     /* seconds */
        suseconds_t tv_usec;    /* microseconds */
    };

and gives the number of seconds and microseconds since the Epoch (see time(2)).  
The tz argument is a struct timezone:

    struct timezone {
        int tz_minuteswest;     /* minutes west of Greenwich */
        int tz_dsttime;         /* type of DST correction */
    };

If either tv or tz is NULL, the corresponding structure is not set or returned.  
(However, compilation warnings will result if tv is NULL.)

The use of the timezone structure is obsolete; 
the tz argument should normally be specified  as  NULL.

#ifdef _MSC_VER

#include <winsock2.h>

//
// gettimeofday - Linux sys/time.h 中得到微秒的一种实现
// tv        :   返回结果包含秒数和微秒数
// tz        :   包含的时区,在winds上这个变量没有用不返回
// return    :   默认返回0
//
inline int
gettimeofday(struct timeval * tv, void * tz) {
    struct tm st;
    SYSTEMTIME wtm;

    GetLocalTime(&wtm);
    st.tm_year = wtm.wYear - 1900;
    st.tm_mon = wtm.wMonth - 1; // winds的计数更好些
    st.tm_mday = wtm.wDay;
    st.tm_hour = wtm.wHour;
    st.tm_min = wtm.wMinute;
    st.tm_sec = wtm.wSecond;
    st.tm_isdst = -1; // 不考虑夏令时

    tv->tv_sec = (long)mktime(&st); // 32位使用数据强转
    tv->tv_usec = wtm.wMilliseconds * 1000; // 毫秒转成微秒

    return 0;
}

#endif

#include <time.h>


/* Set TS to calendar time based in time base BASE.  */
int
timespec_get (struct timespec *ts, int base)
{
  switch (base)
    {
    case TIME_UTC:
      if (__clock_gettime (CLOCK_REALTIME, ts) < 0)
        return 0;
      break;

    default:
      return 0;
    }

  return base;
}

// 1. CL 编译器 设置
引入库 ws2_32.lib 
引入宏 _WINSOCK_DEPRECATED_NO_WARNINGS

// 2. 加载 socket dll
    WSADATA wsad;
    WSAStartup(WINSOCK_VERSION, &wsad);

// 3. 卸载 
    WSACleanup

//
// socket_init - 单例启动socket库的初始化方法
//  
inline void socket_init(void) {
#ifdef _MSC_VER
    WSADATA wsad;
    WSAStartup(WINSOCK_VERSION, &wsad);
#elif __GUNC__
    signal(SIGPIPE, SIG_IGN)  
#endif
}

ssize_t
__libc_recv (int fd, void *buf, size_t len, int flags)
{
#ifdef __ASSUME_RECV_SYSCALL
  return SYSCALL_CANCEL (recv, fd, buf, len, flags);
#elif defined __ASSUME_RECVFROM_SYSCALL
  return SYSCALL_CANCEL (recvfrom, fd, buf, len, flags, NULL, NULL);
#else
  return SOCKETCALL_CANCEL (recv, fd, buf, len, flags);
#endif
}

       #include <sys/types.h>
       #include <sys/socket.h>

       ssize_t recv(int sockfd, void *buf, size_t len, int flags);

       ssize_t recvfrom(int sockfd, void *buf, size_t len, int flags,
                        struct sockaddr *src_addr, socklen_t *addrlen);

#define MSG_OOB         0x1             /* process out-of-band data */
#define MSG_PEEK        0x2             /* peek at incoming message */
#define MSG_DONTROUTE   0x4             /* send without using routing tables */

#if(_WIN32_WINNT >= 0x0502)
#define MSG_WAITALL     0x8             /* do not complete until packet is completely filled */
#endif //(_WIN32_WINNT >= 0x0502)

/*
 *    Perform a listen. Basically, we allow the protocol to do anything
 *    necessary for a listen, and if that works, we mark the socket as
 *    ready for listening.
 */

SYSCALL_DEFINE2(listen, int, fd, int, backlog)
{
    struct socket *sock;
    int err, fput_needed;
    int somaxconn;

    sock = sockfd_lookup_light(fd, &err, &fput_needed);
    if (sock) {
        somaxconn = sock_net(sock->sk)->core.sysctl_somaxconn;
        if ((unsigned int)backlog > somaxconn)
            backlog = somaxconn;

        err = security_socket_listen(sock, backlog);
        if (!err)
            err = sock->ops->listen(sock, backlog);

        fput_light(sock->file, fput_needed);
    }
    return err;
}

listen(fd, SOMAXCONN)

SYSCALL_DEFINE3(accept, int, fd, struct sockaddr __user *, upeer_sockaddr,
        int __user *, upeer_addrlen)
{
    return sys_accept4(fd, upeer_sockaddr, upeer_addrlen, 0);
}

#include <sys/epoll.h>

int epoll_create(int size);
int epoll_create1(int flags);

epoll_create()  creates a new epoll(7) instance.  Since Linux 2.6.8, the size argument is 
ignored, but must be greater than zero; see NOTES below.

epoll_create() returns a file descriptor referring to the new epoll instance.  This file 
descriptor is used for  all  the  subse‐quent  calls to the epoll interface.  When no longer 
required, the file descriptor returned by epoll_create() should be closed by using close(2).  
When all file descriptors referring to an epoll instance have been closed, the kernel 
destroys the instance  and releases the associated resources for reuse.

epoll_create1()
If  flags  is  0, then, other than the fact that the obsolete size argument is dropped, 
epoll_create1() is the same as epoll_create().  The following value can be included in 
flags to obtain different behavior:

EPOLL_CLOEXEC
Set the close-on-exec (FD_CLOEXEC) flag on the new file descriptor.  See the description of 
the O_CLOEXEC flag in  open(2) for reasons why this may be useful.

SYSCALL_DEFINE1(epoll_create, int, size)
{
    if (size <= 0)
        return -EINVAL;

    return sys_epoll_create1(0);
}

epoll_create1(EPOLL_CLOEXEC)

/* Flags for epoll_create1.  */

#define EPOLL_CLOEXEC O_CLOEXEC


/* Valid opcodes to issue to sys_epoll_ctl() */

#define EPOLL_CTL_ADD 1
#define EPOLL_CTL_DEL 2
#define EPOLL_CTL_MOD 3


/* Epoll event masks */

#define EPOLLIN     0x00000001
#define EPOLLPRI    0x00000002
#define EPOLLOUT    0x00000004
#define EPOLLERR    0x00000008
#define EPOLLHUP    0x00000010

/* Set the Edge Triggered behaviour for the target file descriptor */

#define EPOLLET (1U << 31)

//
// sp_wait - poll 的 wait函数, 等待别人自投罗网
// sp       : poll 模型
// e        : 返回的操作事件集
// max      : e 的最大长度
// return   : 返回待操作事件长度, <= 0 表示失败
//
int 
sp_wait(poll_t sp, struct event e[], int max) {
    struct epoll_event ev[max];
    int i, n = epoll_wait(sp, ev, max, -1);

    for (i = 0; i < n; ++i) {
        uint32_t flag = ev[i].events;
        e[i].s = ev[i].data.ptr;
        e[i].write = flag & EPOLLOUT;
        e[i].read = flag & (EPOLLIN | EPOLLHUP);
        e[i].error = flag & EPOLLERR;
    }

    return n;
}

#include <stdio.h>
#include <limits.h>
#include <stdint.h>

//
// 强迫症 × 根治
// file : len.c
// make : gcc -g -Wall -O2 -o love.out love.c
// test : objdump -S love.out
//
int main(int argc, char * argv[]) {
    const char heoo[] = "Hello World";

    for (size_t i = sizeof heoo - 1; i < SIZE_MAX; --i)
        printf(" %c", heoo[i]);
    putchar(‘\n‘);

    return 0;
}