libuv学习笔记（14）

最新推荐文章于 2022-11-20 21:52:43 发布
最新推荐文章于 2022-11-20 21:52:43 发布
阅读量1.6k 收藏
点赞数
分类专栏： libuv学习笔记 文章标签： libuv uv-pipt-t
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/paohui0134/article/details/51712351
版权

libuv学习笔记（14）

uv_pipe_t数据结构以及相关函数（1）

数据结构

typedef struct uv_pipe_s uv_pipe_t;

struct uv_pipe_s {
  UV_HANDLE_FIELDS//uv_handle_t的成员
  UV_STREAM_FIELDS//uv_stream_t的相关成员
  int ipc; 
  //UV_PIPE_PRIVATE_FIELDS展开：
  HANDLE handle;                                                              
  WCHAR* name;                                                               
  union {                                                                    
    struct { //接受用到   服务端相关功能
      int pending_instances;                                               
      uv_pipe_accept_t* accept_reqs;                                          
      uv_pipe_accept_t* pending_accepts;
    } serv;                                 
    struct { //连接用到   客户端相关功能
      uv_timer_t* eof_timer;                                                     
      uv_write_t ipc_header_write_req;                                          
      int ipc_pid;                                                               
      uint64_t remaining_ipc_rawdata_bytes;                                       
      struct {                                                                    
        void* queue[2];                                                           
        int queue_len;                                                          
      } pending_ipc_info;                                                      
      uv_write_t* non_overlapped_writes_tail;                                 
      uv_mutex_t readfile_mutex;                                              
      volatile HANDLE readfile_thread;
    }  conn;                             
  } pipe;

};

相关函数

初始化。导出函数，uv.h中声明，pipe.c中定义
int uv_pipe_init(uv_loop_t* loop, uv_pipe_t* handle, int ipc) 
{
  //流初始化。pipe也是流的一种实现
  uv_stream_init(loop, (uv_stream_t*)handle, UV_NAMED_PIPE);
  handle->reqs_pending = 0;
  handle->handle = INVALID_HANDLE_VALUE;
  handle->name = NULL;
  handle->pipe.conn.ipc_pid = 0;
  handle->pipe.conn.remaining_ipc_rawdata_bytes = 0;
  QUEUE_INIT(&handle->pipe.conn.pending_ipc_info.queue);
  handle->pipe.conn.pending_ipc_info.queue_len = 0;
  handle->ipc = ipc;
  handle->pipe.conn.non_overlapped_writes_tail = NULL;
  handle->pipe.conn.readfile_thread = NULL;
  //写请求初始化
  uv_req_init(loop, (uv_req_t*) &handle->pipe.conn.ipc_header_write_req);
  return 0;
}
打开一个文件描述符作为uv_pipe_t.导出函数，uv.h中声明，pipe.c中定义
int uv_pipe_open(uv_pipe_t* pipe, uv_file file) {
  HANDLE os_handle = uv__get_osfhandle(file);
  NTSTATUS nt_status;
  IO_STATUS_BLOCK io_status;
  FILE_ACCESS_INFORMATION access;
  DWORD duplex_flags = 0;

  if (os_handle == INVALID_HANDLE_VALUE)
    return UV_EBADF;

  //为了避免关闭stdio的文件描述符0-2，使用复制的文件描述符
  if (file <= 2) {
    if (!DuplicateHandle(INVALID_HANDLE_VALUE,
                         os_handle,
                         INVALID_HANDLE_VALUE,
                         &os_handle,
                         0,
                         FALSE,
                         DUPLICATE_SAME_ACCESS))
      return uv_translate_sys_error(GetLastError());
    file = -1;
  }
  //确定句柄权限。
  nt_status = pNtQueryInformationFile(os_handle,
                                      &io_status,
                                      &access,
                                      sizeof(access),
                                      FileAccessInformation);
  if (nt_status != STATUS_SUCCESS)
    return UV_EINVAL;

  if (pipe->ipc) {//跨进程的管道，必须可写 可读
    if (!(access.AccessFlags & FILE_WRITE_DATA) ||
        !(access.AccessFlags & FILE_READ_DATA)) {
      return UV_EINVAL;
    }
  }
  if (access.AccessFlags & FILE_WRITE_DATA)
    duplex_flags |= UV_HANDLE_WRITABLE;
  if (access.AccessFlags & FILE_READ_DATA)
    duplex_flags |= UV_HANDLE_READABLE;
  //设置pipe的句柄
  if (os_handle == INVALID_HANDLE_VALUE ||
      uv_set_pipe_handle(pipe->loop,
                         pipe,
                         os_handle,
                         file,
                         duplex_flags) == -1) {
    return UV_EINVAL;
  }
  //以链接模式初始化pipe
  uv_pipe_connection_init(pipe);

  if (pipe->ipc) {
    assert(!(pipe->flags & UV_HANDLE_NON_OVERLAPPED_PIPE));
    pipe->pipe.conn.ipc_pid = uv_parent_pid();
    assert(pipe->pipe.conn.ipc_pid != -1);
  }
  return 0;
}

设置pipe句柄

static int uv_set_pipe_handle(uv_loop_t* loop,
                              uv_pipe_t* handle,
                              HANDLE pipeHandle,
                              int fd,
                              DWORD duplex_flags) {
  NTSTATUS nt_status;
  IO_STATUS_BLOCK io_status;
  FILE_MODE_INFORMATION mode_info;
  DWORD mode = PIPE_READMODE_BYTE | PIPE_WAIT;
  DWORD current_mode = 0;
  DWORD err = 0;

  if (!(handle->flags & UV_HANDLE_PIPESERVER) &&//非服务端模式
      handle->handle != INVALID_HANDLE_VALUE)//句柄不为空
    return UV_EBUSY;

  if (!SetNamedPipeHandleState(pipeHandle, &mode, NULL, NULL)) {
    err = GetLastError();
    if (err == ERROR_ACCESS_DENIED) {
      /*
       * SetNamedPipeHandleState can fail if the handle doesn't have either
       * GENERIC_WRITE  or FILE_WRITE_ATTRIBUTES.
       * But if the handle already has the desired wait and blocking modes
       * we can continue.
       */
      if (!GetNamedPipeHandleState(pipeHandle, &current_mode, NULL, NULL,
                                   NULL, NULL, 0)) {
        return -1;
      } else if (current_mode & PIPE_NOWAIT) {
        SetLastError(ERROR_ACCESS_DENIED);
        return -1;
      }
    } else {
      /* If this returns ERROR_INVALID_PARAMETER we probably opened
       * something that is not a pipe. */
      if (err == ERROR_INVALID_PARAMETER) {
        SetLastError(WSAENOTSOCK);
      }
      return -1;
    }
  }

  /* Check if the pipe was created with FILE_FLAG_OVERLAPPED. */
  nt_status = pNtQueryInformationFile(pipeHandle,
                                      &io_status,
                                      &mode_info,
                                      sizeof(mode_info),
                                      FileModeInformation);
  if (nt_status != STATUS_SUCCESS) {
    return -1;
  }

  if (mode_info.Mode & FILE_SYNCHRONOUS_IO_ALERT ||
      mode_info.Mode & FILE_SYNCHRONOUS_IO_NONALERT) {
    /* Non-overlapped pipe. */
    handle->flags |= UV_HANDLE_NON_OVERLAPPED_PIPE;
  } else {
    /* Overlapped pipe.  Try to associate with IOCP. */
    if (CreateIoCompletionPort(pipeHandle,
                               loop->iocp,
                               (ULONG_PTR)handle,
                               0) == NULL) {
      handle->flags |= UV_HANDLE_EMULATE_IOCP;
    }
  }

  handle->handle = pipeHandle;
  handle->u.fd = fd;
  handle->flags |= duplex_flags;
  return 0;
}
绑定

创建一个pipe服务端

int uv_pipe_bind(uv_pipe_t* handle, const char* name) {
  uv_loop_t* loop = handle->loop;
  int i, err, nameSize;
  uv_pipe_accept_t* req;
  if (handle->flags & UV_HANDLE_BOUND) {
    return UV_EINVAL;
  }
  if (!name) {
    return UV_EINVAL;
  }
  if (!(handle->flags & UV_HANDLE_PIPESERVER)) {
    handle->pipe.serv.pending_instances = default_pending_pipe_instances;
  }
  //根据pending_instances 申请内部accept请求的内存
  handle->pipe.serv.accept_reqs = (uv_pipe_accept_t*)
    uv__malloc(sizeof(uv_pipe_accept_t) * handle->pipe.serv.pending_instances);
  if (!handle->pipe.serv.accept_reqs) {
    uv_fatal_error(ERROR_OUTOFMEMORY, "uv__malloc");
  }
  //初始化内部accept
  for (i = 0; i < handle->pipe.serv.pending_instances; i++) {
    req = &handle->pipe.serv.accept_reqs[i];
    uv_req_init(loop, (uv_req_t*) req);
    req->type = UV_ACCEPT;
    req->data = handle;
    req->pipeHandle = INVALID_HANDLE_VALUE;
    req->next_pending = NULL;
  }
  //将名字从utf8转到utf16
  nameSize = MultiByteToWideChar(CP_UTF8, 0, name, -1, NULL, 0) * sizeof(WCHAR);
  handle->name = (WCHAR*)uv__malloc(nameSize);
  if (!handle->name) {
    uv_fatal_error(ERROR_OUTOFMEMORY, "uv__malloc");
  }
  if (!MultiByteToWideChar(CP_UTF8,
                           0,
                           name,
                           -1,
                           handle->name,
                           nameSize / sizeof(WCHAR))) {
    err = GetLastError();
    goto error;
  }
  //通过FILE_FLAG_FIRST_PIPE_INSTANCE标记创建管道，如果失败，说明管道已经存在
  handle->pipe.serv.accept_reqs[0].pipeHandle = CreateNamedPipeW(handle->name,
      PIPE_ACCESS_DUPLEX | FILE_FLAG_OVERLAPPED |
      FILE_FLAG_FIRST_PIPE_INSTANCE,
      PIPE_TYPE_BYTE | PIPE_READMODE_BYTE | PIPE_WAIT,
      PIPE_UNLIMITED_INSTANCES, 65536, 65536, 0, NULL);

  if (handle->pipe.serv.accept_reqs[0].pipeHandle == INVALID_HANDLE_VALUE) {
    err = GetLastError();
    if (err == ERROR_ACCESS_DENIED) {
      err = WSAEADDRINUSE;  /* Translates to UV_EADDRINUSE. */
    } else if (err == ERROR_PATH_NOT_FOUND || err == ERROR_INVALID_NAME) {
      err = WSAEACCES;  /* Translates to UV_EACCES. */
    }
    goto error;
  }
  //将新建的管道与uv_pipe_t联系起来
  if (uv_set_pipe_handle(loop,
                         handle,
                         handle->pipe.serv.accept_reqs[0].pipeHandle,
                         -1,
                         0)) {
    err = GetLastError();
    goto error;
  }

  handle->pipe.serv.pending_accepts = NULL;
  handle->flags |= UV_HANDLE_PIPESERVER;
  handle->flags |= UV_HANDLE_BOUND;

  return 0;

error:
  if (handle->name) {
    uv__free(handle->name);
    handle->name = NULL;
  }

  if (handle->pipe.serv.accept_reqs[0].pipeHandle != INVALID_HANDLE_VALUE) {
    CloseHandle(handle->pipe.serv.accept_reqs[0].pipeHandle);
    handle->pipe.serv.accept_reqs[0].pipeHandle = INVALID_HANDLE_VALUE;
  }

  return uv_translate_sys_error(err);
}
链接命名管道

连接一个命名管道

void uv_pipe_connect(uv_connect_t* req, uv_pipe_t* handle,
    const char* name, uv_connect_cb cb) {
  uv_loop_t* loop = handle->loop;
  int err, nameSize;
  HANDLE pipeHandle = INVALID_HANDLE_VALUE;
  DWORD duplex_flags;
  //初始化请求
  uv_req_init(loop, (uv_req_t*) req);
  req->type = UV_CONNECT;
  req->handle = (uv_stream_t*) handle;
  req->cb = cb;
  //utf8转为utf16
  nameSize = MultiByteToWideChar(CP_UTF8, 0, name, -1, NULL, 0) * sizeof(WCHAR);
  handle->name = (WCHAR*)uv__malloc(nameSize);
  if (!handle->name) {
    uv_fatal_error(ERROR_OUTOFMEMORY, "uv__malloc");
  }
  if (!MultiByteToWideChar(CP_UTF8,
                           0,
                           name,
                           -1,
                           handle->name,
                           nameSize / sizeof(WCHAR))) {
    err = GetLastError();
    goto error;
  }
  //打开已存在的管道
  pipeHandle = open_named_pipe(handle->name, &duplex_flags);
  if (pipeHandle == INVALID_HANDLE_VALUE) {
    if (GetLastError() == ERROR_PIPE_BUSY) {
      //管道存在，但是没有可用实例，向线程池注册一个任务，等待管道可用
      if (!QueueUserWorkItem(&pipe_connect_thread_proc,
                             req,
                             WT_EXECUTELONGFUNCTION)) {
        err = GetLastError();
        goto error;
      }
      REGISTER_HANDLE_REQ(loop, handle, req);
      handle->reqs_pending++;
      return;
    }
    err = GetLastError();
    goto error;
  }
  assert(pipeHandle != INVALID_HANDLE_VALUE);
  //将获取的管道与uv_pipe_t联系起来
  if (uv_set_pipe_handle(loop,
                         (uv_pipe_t*) req->handle,
                         pipeHandle,
                         -1,
                         duplex_flags)) {
    err = GetLastError();
    goto error;
  }
  SET_REQ_SUCCESS(req);
  //将请求添加到loop的请求队列
  uv_insert_pending_req(loop, (uv_req_t*) req);
  handle->reqs_pending++;
  REGISTER_HANDLE_REQ(loop, handle, req);
  return;

error:
  if (handle->name) {
    uv__free(handle->name);
    handle->name = NULL;
  }

  if (pipeHandle != INVALID_HANDLE_VALUE) {
    CloseHandle(pipeHandle);
  }

  /* Make this req pending reporting an error. */
  SET_REQ_ERROR(req, err);
  uv_insert_pending_req(loop, (uv_req_t*) req);
  handle->reqs_pending++;
  REGISTER_HANDLE_REQ(loop, handle, req);
  return;
}

uv_process_req中队connect请求的处理，最终会调用

void uv_process_pipe_connect_req(uv_loop_t* loop, uv_pipe_t* handle,
    uv_connect_t* req) {
  int err;
  assert(handle->type == UV_NAMED_PIPE);
  //取消请求注册
  UNREGISTER_HANDLE_REQ(loop, handle, req);
  //调用回调函数
  if (req->cb) {
    err = 0;
    if (REQ_SUCCESS(req)) {
      uv_pipe_connection_init(handle);
    } else {
      err = GET_REQ_ERROR(req);
    }
    req->cb(req, uv_translate_sys_error(err));
  }

  DECREASE_PENDING_REQ_COUNT(handle);
}
paohui0134
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
用libuv库实现管道进程间通信
hello_wcx的博客
12-28 4668
本实例利用了libuv库中的pipe管道实现进程通信，类似与本地套接字。客户端连接服务器端建立连接后相互发送数据 服务端： 文件LocalServer.h #pragma once #include #include #include #include #include #include #include #include using namespace std;
C++封装互斥量和条件变量
linuxcprimerapue的博客
08-04 1196
互斥量 （1）互斥量是保护临界区的另一种方法，当执行线程在临界区的执行时间很长时，那么就最好使用互斥量了，否则会造成其他的线程将会在临界区外忙等，浪费CPU时间；此时其他线程发现临界区已经被互斥量锁住，那么它们将会阻塞；当互斥量被释放时，有多个线程在阻塞，多个线程均会被唤醒，但是只有一个线程可以获得该锁，其他的线程将会继续阻塞； （2）当执行线程需要在临界区睡眠时，那么就最好使用互斥量
进程间通信学习摘记
Andrewniu的博客
12-30 810
对于进程间的通信学习，主要知识点如下。 1.
孙鑫MFC笔记教程(17)--进程间通信2(命名管道)
liufei_learning--脚踏实地，戒骄戒躁！
12-23 5801
用命名管道实现进程间的通信： 命名管道概念：命名管道是通过网络来完成进程间的通信，它屏蔽了底层的网络协议细节。我们在不了解网络协议的情况下，也可以利用命名管道来实现进程间的通信。命名管道充分利用了Windows NT和Windows2000内建的安全机制。将命名管道作为一种网络编程方案时，它实际上建立了一个客户机/服务器通信体系，并在其中可靠的传输数据。命名管道是围绕Win
libuv 中文编程指南---Libuv 基础
hpp24的专栏
11-21 1万+
原文转自：http://www.cnblogs.com/haippy/archive/2013/03/15/2962202.html libuv 采用了 异步 (asynchronous), 事件驱动 (event-driven)的编程风格, 其主要任务是为开人员提供了一套事件循环和基于I/O(或其他活动)通知的回调函数, libuv 提供了一套核心的工具集, 例如定时器, 非阻塞网络编程的
库-libuv：概述
JoeBlackZQQ的专栏
11-10 3189
From： http://blog.chinaunix.net/uid-28458801-id-4464173.html libuv 是 Node 的新跨平台抽象层，用于抽象 Windows 的 IOCP 及 Unix 的 libev。作者打算在这个库的包含所有平台的差异性。 特性： 非阻塞 TCP 套接字 非阻塞命名管道 UDP 定时器 子进程生
libuv学习文档
03-14
这本'书'是一小部分关于使用libuv作为高性能事件I / O库的教程 Windows和Unix上的API相同。 它旨在涵盖libuv的主要领域，但不是讨论每个功能和数据的综合参考 结构体。可以查阅官方libuv文档以获取完整详细信息。 这...
learning-libuv:学习libuv
05-18
libuv学习笔记libuv介绍背景​是一个跨平台的异步IO库实现，刚开始是为Node.js而开发，Node.js完全构建于libuv之上。跨平台构建支持平台WindowsUnixAndroidOS X 注：ios需要自己移植。支持构建工具：autotoolsVisual...
libuv documentation.pdf
08-19
libuv 文档概述 libuv 是一个跨平台支持库，主要关注异步 I/O 操作。它最初是为 Node.js 开发的，但现在也被 Luvit、Julia、pyuv 等其他项目使用。 libuv 的主要特点是它提供了一个全功能的事件循环，支持 epoll、...
C语言libuv-1.42.0源码
最新发布
04-23
**C语言libuv-1.42.0源码详解** `libuv`是一个跨平台的异步I/O库，由C语言编写，主要用于构建事件驱动的非阻塞应用程序。这个库广泛应用于需要高效网络通信的项目，如Node.js、Luvit等。在`libuv-1.42.0`版本中，...
Libuv源码解析 - uv_run
田螺姑娘的博客
11-20 794
Libuv uv_run模块源码解析，包括uv_run之下的所有子模块源码解析。
libuv学习笔记（4）
paohui0134的博客
06-11 1307
libuv学习笔记（4） uv_req_t 基本请求的定义以及相关函数
libuv学习笔记（12）
paohui0134的博客
06-16 3831
libuv学习笔记（12） uv_tcp_t数据结构与相关函数(1)
libuv 高并发异步使用
xcw_1987的博客
04-17 1万+
问题来源： 在开发libuv客户端-服务器时，需要并发的向客户端发送数据，libuv就会用到 uv_write函数，因此，我的初步方案是： 1. 创建线程池； 2. 线程池分配数据内存buf，并打包； 3. 将包发给 uv_write； 4. uv_write_cb 中释放buf; 通过开辟30个线程，发现客户端能正确接收数据，但是无法调用uv_write_cb ，导致内存增加,通过查...
新Nodejs事件循环
Nodejs
06-16 387
先放一张官方提供的事件循环图 官方事件循环机制解析 timers 本阶段执行已经被 setTimeout() 和 setInterval() 的调度回调函数 pending callbacks 此阶段为某些系统操作（例如 TCP 错误类型）执行回调。例如，如果一个 TCP 套接字ECONNREFUSED在尝试连接时收到，一些 *nix 系统希望等待报告错误。这将在挂起的回调阶段排队执行 idle, prepare 系统内部调用 poll poll是一个核心阶段，等新I/O事件的触发，以及执行I/O相关回
孙鑫教学视频笔记(17)进程间通信
peng6662001的专栏
04-06 1772
进程间通信的四种方式剪贴板匿名管道命名管道邮槽Win32平台下，内存块在物理内存中从来不会被移动，但可以在缺省的堆中被移动剪贴板将数据存入剪贴板：void CClipboardDlg::OnBnClickedBtnSend(){ // TODO: 在此添加控件通知处理程序代码 if(OpenClipboard()) {  CString str;  char * pBuf;  HANDLE
SetNamedPipeHandleState
weixin_40332490的博客
04-03 801
函数原型 BOOL SetNamedPipeHandleState( HANDLE hNamedPipe, LPDWORD lpMode, LPDWORD lpMaxCollectionCount, LPDWORD lpCollectDataTimeout ); 函数参数 hNamedPipe 此参数可以是CreateNamedPipe函数返回的管道服务器端的句柄，也可以是Cr...
基于libuv的TCP设计
热门推荐
wqvbjhc的专栏
05-15 2万+
本人一直在寻找一个跨平台的网络库，
libuv API详解与实战示例
"libuv API说明及用例，英文文档，适用于多平台，专注于异步I/O操作，主要被Node.js、Luvit、Julia、pyuv等使用。文档包含了错误报告指引、全面的特性列表，如事件循环、异步网络和DNS解析、文件系统操作等。" ...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值