C语言JSON-RPC

最新推荐文章于 2024-08-10 07:17:33 发布
最新推荐文章于 2024-08-10 07:17:33 发布
阅读量653 收藏 3
点赞数 1
文章标签： c/c++ json 网络

     近期对json-rpc比較感兴趣，思想非常easy，并且看到了非常多不同语言的实现。在github上 hmngomes 的 json-rpc-c （实现的是server端，基于TCP流），短小精悍，提供了非常好的框架。代码十分清晰。易于扩展，并且代码easy看懂，非常经典。该实现依赖于其他两个库 libev 和 cJSON。值得认真学习。
     測试的时候先启动server，而后通过 nc 命令发送对应的json格式数据，就会有对应的效果：
vonzhou@de15:~$ echo "{\"method\":\"sayHello\"}" | nc localhost 1234
{
     "result":     "Hello!"
}
vonzhou@de15:~$ echo "{\"method\":\"exit\"}" | nc localhost 1234
{
     "result":     "Bye!"
}


以下贴出代码，便于温习。

-------------------server.c
#include   <stdio.h>
#include   <stdlib.h>
#include   <unistd.h>
#include   <errno.h>
#include   <string.h>
#include   <sys/types.h>
#include  <sys/socket.h>
#include  <netinet/in.h>
#include  <netdb.h>
#include  <arpa/inet.h>
#include  <sys/wait.h>
#include   <signal.h>
#include  "jsonrpc-c.h"

#define  PORT 1234   // the port users will be connecting to

struct  jrpc_server my_server;

cJSON * say_hello(  jrpc_context  * ctx, cJSON * params, cJSON *id) {
       return  cJSON_CreateString(  "Hello!"  );
}

cJSON * exit_server(  jrpc_context  * ctx, cJSON * params, cJSON *id) {
     jrpc_server_stop(&my_server);
       return  cJSON_CreateString(  "Bye!"  );
}

int  main(  void  ) {
     jrpc_server_init(&my_server, PORT);
     //注冊俩方法
     jrpc_register_procedure(&my_server, say_hello,  "sayHello"  , NULL );
     jrpc_register_procedure(&my_server, exit_server,  "exit"  , NULL );
     jrpc_server_run(&my_server);
     jrpc_server_destroy(&my_server);
       return  0;
}

-----------------json-rpc.h
#ifndef  JSONRPCC_H_
#define  JSONRPCC_H_

#include  "cJSON.h"
#include  <ev.h>

/*
 *
 * http://www.jsonrpc.org/specification
 *
 * code   message   meaning
 * -32700 Parse error   Invalid JSON was received by the server.
 * An error occurred on the server while parsing the JSON text.
 * -32600 Invalid Request    The JSON sent is not a valid Request object.
 * -32601 Method not found   The method does not exist / is not available.
 * -32602 Invalid paramsInvalid method parameter(s).
 * -32603 Internal errorInternal JSON-RPC error.
 * -32000 to -32099Server error  Reserved for implementation-defined server-errors.
 */

#define  JRPC_PARSE_ERROR -32700
#define  JRPC_INVALID_REQUEST -32600
#define  JRPC_METHOD_NOT_FOUND -32601
#define  JRPC_INVALID_PARAMS -32603
#define  JRPC_INTERNAL_ERROR -32693


typedef   struct  {
       void  *  data ;
       int   error_code ;
       char  *  error_message  ;
}  jrpc_context ;

//JSON方法类型
typedef  cJSON* (*  jrpc_function  )( jrpc_context  *context, cJSON *params, cJSON* id);

struct  jrpc_procedure {
       char  *  name ;  //方法名
       jrpc_function   function ;  //方法地址
       void  *  data ;  //额外信息
};


struct  jrpc_server {
       int   port_number ;
       struct  ev_loop *  loop ;  //eventloop类型
      ev_io  listen_watcher  ;  //
       int   procedure_count ;  
       struct  jrpc_procedure *  procedures  ;
       int   debug_level ;
};

struct  jrpc_connection {
       struct  ev_io  io ;
       int   fd ;
       int   pos ;  //记录在buffer中的位置
       unsigned   int   buffer_size  ;
       char  *  buffer ;
       int   debug_level ;
};

int  jrpc_server_init(  struct  jrpc_server *server,  int  port_number);

int  jrpc_server_init_with_ev_loop(  struct  jrpc_server *server,
         int  port_number,  struct  ev_loop *loop);

static   int  __jrpc_server_start ( struct  jrpc_server *server);

void  jrpc_server_run(  struct  jrpc_server *server);

int  jrpc_server_stop(  struct  jrpc_server *server);

void  jrpc_server_destroy(  struct  jrpc_server *server);

static   void  jrpc_procedure_destroy ( struct  jrpc_procedure *procedure);

int  jrpc_register_procedure(  struct  jrpc_server *server,
            jrpc_function  function_pointer,  char  *name,  void  *data);

int  jrpc_deregister_procedure(  struct  jrpc_server *server,  char  *name);

#endif
 
-----------------json-rpc.c
#include   <stdio.h>
#include   <stdlib.h>
#include   <unistd.h>
#include   <errno.h>
#include   <string.h>
#include   <sys/types.h>
#include  <sys/socket.h>
#include  <netinet/in.h>
#include  <netdb.h>
#include  <arpa/inet.h>

#include  "jsonrpc-c.h"

struct  ev_loop *loop;

// get sockaddr, IPv4 or IPv6:
static   void  *get_in_addr(  struct  sockaddr *sa) {
       if  (sa-> sa_family == AF_INET) {
            return  &((( struct  sockaddr_in*) sa)->sin_addr );
     }
       return  &(((  struct  sockaddr_in6*) sa)->sin6_addr);
}

static   int  send_response(  struct  jrpc_connection * conn,  char  *response) {
       int  fd = conn->  fd ;
       if  (conn->  debug_level  > 1)
            printf  ( "JSON Response:\n%s\n"  , response);
       write (fd, response,  strlen  (response));
       write (fd,  "\n"  , 1);
       return  0;
}

static   int  send_error(  struct  jrpc_connection * conn,  int  code,  char  * message,
           cJSON * id) {
       int  return_value = 0;
      cJSON *result_root = cJSON_CreateObject();
      cJSON *error_root = cJSON_CreateObject();
     cJSON_AddNumberToObject(error_root,  "code"  , code);
     cJSON_AddStringToObject(error_root,  "message"  , message);
     cJSON_AddItemToObject(result_root,  "error"  , error_root);
     cJSON_AddItemToObject(result_root,  "id"  , id);
       char  * str_result = cJSON_Print(result_root);
     return_value = send_response(conn, str_result);
       free (str_result);
     cJSON_Delete(result_root);
       free (message);
       return  return_value;
}

static   int  send_result(  struct  jrpc_connection * conn, cJSON * result,
           cJSON * id) {
       int  return_value = 0;
      cJSON *result_root = cJSON_CreateObject();
       if  (result)
          cJSON_AddItemToObject(result_root,  "result"  , result);
     cJSON_AddItemToObject(result_root,  "id"  , id);

       char  * str_result = cJSON_Print(result_root);
     return_value = send_response(conn, str_result);
       free (str_result);
     cJSON_Delete(result_root);
       return  return_value;
}

static   int  invoke_procedure(  struct  jrpc_server *server,
            struct  jrpc_connection * conn,  char  *name, cJSON *params, cJSON *id) {
      cJSON *returned = NULL;
       int  procedure_found = 0;
       jrpc_context  ctx;
     ctx.  error_code  = 0;
     ctx.  error_message  = NULL;
       int  i = server->  procedure_count  ;
       while  (i--) {
            if  (! strcmp  (server->  procedures [i].  name , name)) {
              procedure_found = 1;
              ctx.  data  = server->  procedures  [i]. data  ;
              returned = server-> procedures  [i]. function  (&ctx, params, id);
                break  ;
          }
     }
       if  (!procedure_found)
            return  send_error(conn, JRPC_METHOD_NOT_FOUND,
                     strdup  ( "Method not found."  ), id);
       else  {
            if  (ctx. error_code  )
                return  send_error(conn, ctx. error_code  , ctx. error_message  , id);
            else
                return  send_result(conn, returned, id);
     }
}

static   int  eval_request ( struct  jrpc_server *server,
            struct  jrpc_connection * conn, cJSON *root) {
      cJSON *method, *params, *id;
     method = cJSON_GetObjectItem(root,  "method"  );
       if  (method != NULL && method-> type == cJSON_String ) {
          params = cJSON_GetObjectItem(root,  "params " );
            if  (params == NULL|| params->type == cJSON_Array
          || params-> type == cJSON_Object ) {
              id = cJSON_GetObjectItem(root,  "id"  );
                if  (id == NULL|| id->type == cJSON_String
              || id-> type == cJSON_Number ) {
                //We have to copy ID because using it on the reply and deleting the response Object will also delete ID
                    cJSON * id_copy = NULL;
                     if  (id != NULL)
                        id_copy =
                                  (id-> type == cJSON_String) ? cJSON_CreateString(
                                           id-> valuestring) :
                                           cJSON_CreateNumber(id-> valueint);
                     if  (server-> debug_level  )
                          printf  ( "Method Invoked: %s\n"  , method->valuestring);
                     return  invoke_procedure(server, conn, method->valuestring,
                             params, id_copy);
              }
          }
     }
     send_error(conn, JRPC_INVALID_REQUEST,
                strdup  ( "The JSON sent is not a valid Request object." ), NULL);
       return  -1;
}

static   void  close_connection(  struct  ev_loop *loop, ev_io *w) {
     ev_io_stop(loop, w);
       close (((  struct  jrpc_connection *) w)-> fd  );
       free (((  struct  jrpc_connection *) w)-> buffer  );
       free (((  struct  jrpc_connection *) w));
}

static   void  connection_cb(  struct  ev_loop *loop, ev_io *w,  int  revents) {
       struct  jrpc_connection *conn;
       struct  jrpc_server *server = (  struct  jrpc_server *) w->data;
       size_t  bytes_read = 0;
       //get our 'subclassed' event watcher
     conn = (  struct  jrpc_connection *) w;
       int  fd = conn->  fd ;
       // 为这个session 分配的buffer满了，须要又一次分配空间，成倍增长
       if  (conn->  pos  == (conn->  buffer_size  - 1)) {
            char  * new_buffer =  realloc (conn->  buffer , conn-> buffer_size  *= 2);
            if  (new_buffer == NULL) {
                perror  ( "Memory error"  );
                return  close_connection(loop, w);
          }
          conn->  buffer  = new_buffer;
            //把后来增长的空间置空
            memset  (conn-> buffer  + conn->  pos , 0, conn-> buffer_size  - conn-> pos  );
     }
       // can not fill the entire buffer, string must be NULL terminated
       int  max_read_size = conn->  buffer_size  - conn-> pos  - 1;
       //从套接字中读取数据。-1 说明异常终止
       if  ((bytes_read =  read  (fd, conn-> buffer  + conn->  pos , max_read_size))
              == -1) {
            perror  ( "read"  );
            return  close_connection(loop, w);
     }
       //为0说明client关闭连接
       if  (!bytes_read) {
            // client closed the sending half of the connection
            if  (server-> debug_level  )
                printf  ( "Client closed connection.\n"  );
            return  close_connection(loop, w);
     }  else  {
           cJSON *root;
            char  *end_ptr = NULL;
          conn->  pos  += bytes_read;

            if  ((root = cJSON_Parse_Stream(conn-> buffer  , &end_ptr)) != NULL) {
                if  (server-> debug_level  > 1) {
                     char  * str_result = cJSON_Print(root);
                     printf  ( "Valid JSON Received:\n%s\n"  , str_result);
                     free  (str_result);
              }

                if  (root->type == cJSON_Object) {
                    eval_request(server, conn, root);
              }
                //shift processed request, discarding it
                memmove  (conn-> buffer  , end_ptr,  strlen  (end_ptr) + 2);

              conn->  pos  =  strlen  (end_ptr);
                memset  (conn-> buffer  + conn->  pos , 0,
                        conn->  buffer_size  - conn-> pos  - 1);

              cJSON_Delete(root);
          }  else  {
                // did we parse the all buffer?

If so, just wait for more.

                // else there was an error before the buffer's end
                if  (end_ptr != (conn-> buffer  + conn->  pos )) {
                     if  (server-> debug_level  ) {
                          printf  ( "INVALID JSON Received:\n---\n%s\n---\n" ,
                                  conn->  buffer );
                   }
                   send_error(conn, JRPC_PARSE_ERROR,
                               strdup  (
                                        "Parse error. Invalid JSON was received by the server." ),
                             NULL);
                     return  close_connection(loop, w);
              }
          }
     }

}

static   void  accept_cb(  struct  ev_loop *loop, ev_io *w,  int  revents) {
       char  s[ INET6_ADDRSTRLEN];
       struct  jrpc_connection *connection_watcher;
     connection_watcher =  malloc  ( sizeof  (  struct  jrpc_connection));
       //通用socket addr
       struct  sockaddr_storage their_addr;  // connector's address information
      socklen_t sin_size;
     sin_size =  sizeof  their_addr;
     connection_watcher->  fd  = accept(w-> fd, (  struct  sockaddr *) &their_addr,
              &sin_size);
       if  (connection_watcher->  fd  == -1) {
            perror  ( "accept"  );
            free  (connection_watcher);
     }  else  {
            if  ((( struct  jrpc_server *) w->data)->  debug_level ) {
              inet_ntop(their_addr.  ss_family  ,
                        get_in_addr((  struct  sockaddr *) &their_addr), s,  sizeof  s);
                printf  ( "server: got connection from %s\n"  , s);
          }
          ev_io_init(&connection_watcher->  io , connection_cb,
                   connection_watcher->  fd , EV_READ);
            //copy pointer to struct jrpc_server
          connection_watcher->  io . data = w->data ;
          connection_watcher->  buffer_size  = 1500;
          connection_watcher->  buffer  =  malloc  (1500);
            memset  (connection_watcher-> buffer  , 0, 1500);
          connection_watcher->  pos  = 0;
            //copy debug_level, struct jrpc_connection has no pointer to struct jrpc_server
          connection_watcher->  debug_level  =
                   ((  struct  jrpc_server *) w->data)->  debug_level ;
          ev_io_start(loop, &connection_watcher->  io );
     }
}

int  jrpc_server_init(  struct  jrpc_server *server,  int  port_number) {
    loop = EV_DEFAULT;
     return  jrpc_server_init_with_ev_loop(server, port_number, loop);
}

int  jrpc_server_init_with_ev_loop(  struct  jrpc_server *server,
         int  port_number,  struct  ev_loop *loop) {
       memset (server, 0,  sizeof  ( struct  jrpc_server));
     server->  loop  = loop;
     server->  port_number  = port_number;
       char  * debug_level_env =  getenv  ( "JRPC_DEBUG"  );
       if  (debug_level_env == NULL)
          server->  debug_level  = 0;
       else  {
          server->  debug_level  =  strtol  (debug_level_env, NULL, 10);
            printf  ( "JSONRPC-C Debug level %d\n"  , server-> debug_level  );
     }
       return  __jrpc_server_start(server);
}

static   int  __jrpc_server_start ( struct  jrpc_server *server) {
       int  sockfd;
       struct  addrinfo hints, *servinfo, *p;
       struct  sockaddr_in sockaddr;
       int  len;
       int  yes = 1;
       int  rv;
       char  PORT[6];
       sprintf (PORT,  "%d"  , server-> port_number  );
       memset (&hints, 0,  sizeof  hints);
     hints.  ai_family  = AF_UNSPEC;
     hints.  ai_socktype  = SOCK_STREAM;
     hints.  ai_flags  = AI_PASSIVE;  // use my IP

       if  ((rv = getaddrinfo(NULL, PORT, &hints, &servinfo)) != 0) {
            fprintf  (stderr,  " getaddrinfo: %s\n"  , gai_strerror(rv));
            return  1;
     }

// loop through all the results and bind to the first we can
       for  (p = servinfo; p != NULL; p = p->  ai_next ) {
            if  ((sockfd = socket(p-> ai_family  , p-> ai_socktype  , p-> ai_protocol  ))
                   == -1) {
                perror  ( "server: socket"  );
                continue  ;
          }

            if  (setsockopt(sockfd, SOL_SOCKET, SO_REUSEADDR, &yes,  sizeof  ( int  ))
                   == -1) {
                perror  ( " setsockopt"  );
                exit  (1);
          }

            if  (bind(sockfd, p-> ai_addr  , p-> ai_addrlen  ) == -1) {
                close  (sockfd);
                perror  ( "server: bind"  );
                continue  ;
          }

          len =  sizeof  (sockaddr);
            if  (getsockname(sockfd, (  struct  sockaddr *) &sockaddr, &len) == -1) {
                close  (sockfd);
                perror  ( "server: getsockname"  );
                continue  ;
          }
          server->  port_number  = ntohs( sockaddr. sin_port  );

            break  ;
     }

       if  (p == NULL) {
            fprintf  (stderr,  "server: failed to bind\n"  );
            return  2;
     }

     freeaddrinfo(servinfo);  // all done with this structure

       if  (listen(sockfd, 5) == -1) {
            perror  ( "listen"  );
            exit  (1);
     }
       if  (server->  debug_level  )
            printf  ( "server: waiting for connections...\n"  );

     ev_io_init(&server->  listen_watcher  , accept_cb, sockfd, EV_READ);
     server->  listen_watcher  .data = server;
     ev_io_start(server->  loop , &server->  listen_watcher  );
       return  0;
}

// Make the code work with both the old (ev_loop/ev_unloop)
// and new (ev_run/ev_break) versions of libev.
#ifdef  EVUNLOOP_ALL
   #define  EV_RUN ev_loop
   #define  EV_BREAK ev_unloop
   #define  EVBREAK_ALL EVUNLOOP_ALL
#else
   #define  EV_RUN ev_run
   #define  EV_BREAK ev_break
#endif

void  jrpc_server_run(  struct  jrpc_server *server){
     EV_RUN(server->  loop , 0);
}

int  jrpc_server_stop(  struct  jrpc_server *server) {
     EV_BREAK(server->  loop , EVBREAK_ALL);
       return  0;
}

void  jrpc_server_destroy(  struct  jrpc_server *server){
       /* Don't destroy server */
       int  i;
       for  (i = 0; i < server->  procedure_count  ; i++){
          jrpc_procedure_destroy( &(server->  procedures  [i]) );
     }
       free (server->  procedures  );
}

static   void  jrpc_procedure_destroy ( struct  jrpc_procedure *procedure){
       if  (procedure->  name ){
            free  (procedure-> name  );
          procedure->  name  = NULL;
     }
       if  (procedure->  data ){
            free  (procedure-> data  );
          procedure->  data  = NULL;
     }
}

int  jrpc_register_procedure(  struct  jrpc_server *server,
            jrpc_function  function_pointer,  char  *name,  void  * data) {
       int  i = server->  procedure_count  ++;
       if  (!server->  procedures  )
          server->  procedures  =  malloc  (  sizeof (  struct  jrpc_procedure));
       else  {
            //每次添加一个jrpc_procedure空间
            struct  jrpc_procedure * ptr =  realloc  (server-> procedures  ,
                     sizeof  ( struct  jrpc_procedure) * server-> procedure_count  );
            if  (!ptr)
                return  -1;
          server->  procedures  = ptr;

     }
       //name是局部变量，所以要 strdup
       if  ((server->  procedures  [i]. name  =  strdup (name)) == NULL)
            return  -1;
     server->  procedures  [i]. function  = function_pointer;
     server->  procedures  [i]. data  = data;
       return  0;
}

int  jrpc_deregister_procedure(  struct  jrpc_server *server,  char  *name) {
       /* Search the procedure to deregister */
       int  i;
       int  found = 0;
       if  (server->  procedures  ){
            for  (i = 0; i < server-> procedure_count  ; i++){
                if  (found)
                   server->  procedures  [i-1] = server-> procedures  [i];
                else   if  (!  strcmp (name, server-> procedures  [i]. name  )){
                   found = 1;
                   jrpc_procedure_destroy( &(server-> procedures  [i]) );
              }
          }
            if  (found){
              server->  procedure_count  --;
                if  (server-> procedure_count  ){
                     struct  jrpc_procedure * ptr =  realloc  (server-> procedures  ,
                          sizeof  ( struct  jrpc_procedure) * server-> procedure_count  );
                     if  (!ptr){
                          perror  ( " realloc"  );
                          return  -1;
                   }
                   server->  procedures  = ptr;
              }  else  {
                   server->  procedures  = NULL;
              }
          }
     }  else  {
            fprintf  (stderr,  "server : procedure '%s' not found\n" , name);
            return  -1;
     }
       return  0;
}

----------当中关于cJSON代码部分。见 C语言解析JSON部分。

參考：




weixin_33721344
关注
C语言实现JSON-RPC
博观约取
07-08 1万+
最近对json-rpc比较感兴趣，思想很简单，而且看到了很多不同语言的实现。在github上 hmngomes 的 json-rpc-c （实现的是server端，基于TCP流），短小精悍，提供了很好的框架，代码十分清晰，易于扩展，而且代码容易看懂，很经典。该实现依赖于其它两个库 libev 和 cJSON，值得认真学习。      测试的时候先启动server，而后通过 nc 命令发送相应的j
jsonrpc-c：C中的JSON-RPC（仅服务器）
02-01
"jsonrpc-c"是一个专门为C语言设计的JSON-RPC库，它专注于服务器端的实现，因此不包含客户端的部分。 **JSON-RPC基础知识** 1. **JSON-RPC协议**: JSON-RPC允许服务消费者通过HTTP或其它传输协议向服务提供者发送...
json-rpc协议C语言版
03-15
JSON-RPC协议的C语言版与Python语言版，源代码及示例
探索jsonrpc-c：构建灵活的C语言服务端RPC解决方案
最新发布
gitblog_00438的博客
08-10 257
探索jsonrpc-c：构建灵活的C语言服务端RPC解决方案 jsonrpc-cJSON-RPC in C (server only for now)项目地址:https://gitcode.com/gh_mirrors/js/jsonrpc-c 项目介绍 在寻找一种简单而直接的方法来配置嵌入式Linux系统上的C应用程序时，我们发现了jsonrpc-c。这个项目专注于提供TCP套接字上的JSO...
jsonrpc-c: 高性能的 JSON-RPC 实现
gitblog_00081的博客
03-16 548
jsonrpc-c: 高性能的 JSON-RPC 实现 jsonrpc-cJSON-RPC in C (server only for now)项目地址:https://gitcode.com/gh_mirrors/js/jsonrpc-c 项目简介 jsonrpc-c 是一个 C 语言编写的高性能 JSON-RPC 库，它提供了对 JSON-RPC 1.0 和 2.0 规范的支持，并且支持多种...
C语言json串的安全检查,C语言实现jsonrpc
weixin_39578516的博客
05-19 277
程序说明:该代码是在jsonrpc-c的基础上，添加jsonrpc-2.0支持(版本信息，批处理等)，添加http协议支持，增加客户端代码得到，如果使用过程中发现有bug以后会再加以修改。编译使用:cd third_partytar -zxvf libev-4.22.tar.gzcd libev-4.22./configure && make && make ins...
C语言编写的简单HTTP json RPC
u013131653的博客
04-25 1337
目录0 概述0.0 参考0.1 HTTP 服务0.2 JSON RPC HTTP错误码0.3 目录结构1 使用1.1 接口访问示例1.2 方法注册1.3 修改监听端口 0 概述 0.0 参考 GitHub - hmng/jsonrpc-c: JSON-RPC in C (server only for now) GitHub - cesanta/mongoose: Embedded Web Server GitHub - DaveGamble/cJSON: Ultralightweight JSON par
jsonrpc-c-master 基于 json rpc 1.0 纯C开发的服务端代码和示例
03-27
基于JSON-RPC 1.0的C语言实现，如"jsonrpc-c-master"，提供了一种在C语言环境中构建服务端应用的方法，尤其适用于嵌入式系统或对性能有严格要求的环境。 **JSON-RPC 1.0协议基础** JSON-RPC 1.0是一个简单的请求/...
jsonrpcpp:C ++ JSON-RPC 2.0库
05-10
jsonrpc ++ 轻巧的C ++ 库 这是什么 jsonrpc ++解析并构造对象，例如 示例：解析请求 jsonrpcpp::entity_ptr entity = jsonrpcpp::Parser::do_parse( R"( {"jsonrpc": "2.0", "method": "subtract", "params": {...
c/c++ json-rpc demo
08-08
有两个demo 1： 一个是c的json-rpc 2： 另一个是c++ json-rpc
JSON json-rpc 及json-c-0.9的例子
sphone89的专栏
06-27 7354
1、下载并解压json-c-0.9 #wget http://oss.metaparadigm.com/json-c/json-c-0.9.tar.gz #tar -zxvf json-c-0.9.tar.gz 2、编译json-c-0.9 #cd json-c-0.9/ # ./configure --prefix=/home/usrname/json/out --enable-sha
cpp-libjsonrpccpp用于C服务器和客户端的JSONRPC框架
08-15
libjson-rpc-cpp - 用于C 服务器和客户端的JSON-RPC框架
JsonRpc-Cpp
11-30
JsonRpc-Cpp - JSON-RPC implementation. * Copyright (C) 2008-2011 Sebastien Vincent * * This program is free software: you can redistribute it and/or modify * it under the terms of the GNU Lesser General Public License as published by * the Free Software Foundation, either version 3 of the License, or * (at your option) any later version. JsonRpc-Cpp provides a JSON-RPC class called Json::Rpc::Handler that contains RPC methods, check incoming JSON-RPC message, * reply either with success or error code (in case parsing failed, ...). * * JsonRpc-Cpp provides also simple JSON-RPC TCP and UDP server implementations (Json::Rpc::TcpServer and Json::Rpc::UdpServer) as well * as simple JSON-RPC TCP and UDP client implementations (Json::Rpc::TcpClient and Json::Rpc::UdpClient). * * \section section-build Build instructions * * To build and install JsonRpc-Cpp, see INSTALL file located in the source tree. * * \section section-standard Standards
json-rpc的C ++框架（json远程过程调用）-C/C++开发
05-26
libjson-rpc-cpp此框​​架为C ++提供跨平台的JSON-RPC（远程过程调用）支持。 它与JSON-RPC 2.0和1.0完全兼容。 在下一个RPC项目中使用libjson-rpc-cpp的5个很好的理由libjson-rpc-cpp此框​​架为C ++提供跨平台的JSON-RPC（远程过程调用）支持。 它与JSON-RPC 2.0和1.0完全兼容。 在您的下一个RPC项目中使用libjson-rpc-cpp的5个很好的理由：全面的JSON-RPC 2.0和1.0客户端和服务器支持。 jsonrpcstub-一种为JSON-RPC客户端和服务器应用程序生成存根类的工具。 准备使用HTTP + TCP服务器和客户端为JSON-RPC应用程序提供简单的接口。 跨平台构建支持和
纯C实现jsonrpc
weixin_34049948的博客
03-08 384
2019独角兽企业重金招聘Python工程师标准>>> ...
【初学jsonrpc之开源库jsonrpc-c】
ysdzkj的博客
12-29 510
我的理解，jsonrpc就是一种规范的网络传输协议，传输数据是json格式，具体格式可查阅相关资料。jsonrpc还有另一种官方称呼叫远程调用接口，什么意思？即客户端发送的json数据中包含了一个叫method子项，对应的就是服务端的接口函数。例如，method的值是add，那么当服务端解析到add时会直接响应已注册的add接口，返回相应的数据。所以，jsonrpc又叫远程调用接口，意思就是客户端可以远程调用服务端的接口。
centos7安装jsonrpc-cpp，并运行实例
u013720726的博客
04-21 2348
预安装软件或库 scons——用于编译 curl——库文件 jsoncpp——库文件 下载jsonrpc-cpp下载地址，下载 jsonrpc-cpp-0.5.tar.bz2 解压缩#tar -jxvf jsonrpc-cpp-0.5.tar.bz2 进入jsonrpc目录 #cd jsonrpc-cpp-0.5 编译 #scons 把jsonrpc目录下include子目录下的文件全部
请简述为什么是JSON?什么物联网通信中常用JSON进行数据交换?并简要介绍C语言下的JSON编解码库
06-11
在C语言中，有一些常用的JSON编解码库，例如cJSON、JSON-C、Jansson等。这些库提供了一些API函数，可以方便地对JSON格式的数据进行解析和生成。其中，cJSON是一款轻量级的JSON解析库，使用简单，只需要一个cJSON.h...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值