纯C语言版本的socket.io服务器端实现

前言

网站建设哪家好，找创新互联！专注于网页设计、网站建设、微信开发、微信平台小程序开发、集团企业网站建设等服务项目。为回馈新老客户创新互联还提供了化州免费建站欢迎大家使用！

哈，这又是一个socket.io服务端实现，本意是，拿C练练手，加强对C和linux系统的理解，写着写着，就写成了一个socket.io服务器端实现了。以为半成品，那就正式托管在github站点上吧，以便记录一下，可让大家批评与指正，加强内功的修炼等。

项目地址为：yongboy/c_socket.io_server

以下部分文字，偷懒，摘录自项目的README.md文件

说明

这是一个纯C语言版本的socket.io服务器端实现，目前仅支持linux系统，严重依赖libev and glib等基础库。

在运行socket.io_server之前，需要安装以下依赖：

 
 
 
    
  
  
  
  1. sudo apt-get install uuid-dev  
    2. 
  
  
  
  2. sudo apt-get install libglib2.0-dev  
    3.

如何运行

  1. 编写实现代码（eg:chatroom.c），需要包含头文件 endpoint_impl.h
  2. 把实现代码(eg:chatroom.c)放入examples目录
  3. 编写对应的html文件，放入static目录
  4. 编辑Makefile文件
  5. 终端下运行make命令
  6. 然后敲入 ./socket.io_server 接口运行
  7. 打开浏览器即可访问 (eg:http://localhost:8000/chatroom.html)

API说明

对外的API，可以在头文件 endpoint_impl.h 看到其定义，其继承了另外一个公用的头文件 endpoint.h, 其完整定义为：

 
 
 
    
  
  
  
  1. #include   
    2. 
  
  
  
  2. #include   
    3. 
  
  
  
  3. #include   
    4. 
  
  
  
  4.  
    5. 
  
  
  
  5. typedef struct {  
    6. 
  
  
  
  6.     char *message_type;  
    7. 
  
  
  
  7.     char *message_id;  
    8. 
  
  
  
  8.     char *endpoint;  
    9. 
  
  
  
  9.     char *message_data;  
    10. 
  
  
  
  10.     char *ori_data;  
    11. 
  
  
  
  11. } message_fields;  
    12. 
  
  
  
  12.  
    13. 
  
  
  
  13. typedef struct {  
    14. 
  
  
  
  14.     char *endpoint;  
    15. 
  
  
  
  15.     void (*on_init)(const char *endpoint);  
    16. 
  
  
  
  16.     void (*on_connect)(const char *sessionid);  
    17. 
  
  
  
  17.     void (*on_message)(const char *sessionid, const message_fields *msg_fields);  
    18. 
  
  
  
  18.     void (*on_json_message)(const char *sessionid, const message_fields *msg_fields);  
    19. 
  
  
  
  19.     void (*on_event)(const char *sessionid, const message_fields *msg_fields);  
    20. 
  
  
  
  20.     void (*on_other)(const char *sessionid, const message_fields *msg_fields);  
    21. 
  
  
  
  21.     void (*on_disconnect)(const char *sessionid, const message_fields *msg_fields);  
    22. 
  
  
  
  22.     void (*on_destroy)(const char *endpoint);  
    23. 
  
  
  
  23. } endpoint_implement;  
    24. 
  
  
  
  24.  
    25. 
  
  
  
  25. extern void send_msg(char *sessionid, char *message);  
    26. 
  
  
  
  26. extern void broadcast_clients(char *except_sessionid, char *message);  
    27. 
  
  
  
  27.  
    28. 
  
  
  
  28. static void on_init(const char *endpoint);  
    29. 
  
  
  
  29. static void on_connect(const char *sessionid);  
    30. 
  
  
  
  30. static void on_message(const char *sessionid, const message_fields *msg_fields) {  
    31. 
  
  
  
  31.     printf("on_message recevie ori msg is %s\n", msg_fields->ori_data);  
    32. 
  
  
  
  32. }  
    33. 
  
  
  
  33. static void on_json_message(const char *sessionid, const message_fields *msg_fields) {  
    34. 
  
  
  
  34.     printf("on_json_message recevie ori msg is %s\n", msg_fields->ori_data);  
    35. 
  
  
  
  35. }  
    36. 
  
  
  
  36. static void on_other(const char *sessionid, const message_fields *msg_fields) {  
    37. 
  
  
  
  37.     printf("on_other recevie ori msg is %s\n", msg_fields->ori_data);  
    38. 
  
  
  
  38. }  
    39. 
  
  
  
  39. static void on_event(const char *sessionid, const message_fields *msg_fields);  
    40. 
  
  
  
  40. static void on_disconnect(const char *sessionid, const message_fields *msg_fields);  
    41. 
  
  
  
  41. static void on_destroy(const char *endpoint);  
    42. 
  
  
  
  42.  
    43. 
  
  
  
  43. static endpoint_implement *init_default_endpoint_implement(char *endpoint_name) {  
    44. 
  
  
  
  44.     endpoint_implement *impl_point = (endpoint_implement *)malloc(sizeof(endpoint_implement));  
    45. 
  
  
  
  45.     impl_point->endpoint = strdup(endpoint_name);  
    46. 
  
  
  
  46.  
    47. 
  
  
  
  47.     impl_point->on_init = on_init;  
    48. 
  
  
  
  48.     impl_point->on_connect = on_connect;  
    49. 
  
  
  
  49.     impl_point->on_message = on_message;  
    50. 
  
  
  
  50.     impl_point->on_json_message = on_json_message;  
    51. 
  
  
  
  51.     impl_point->on_event = on_event;  
    52. 
  
  
  
  52.     impl_point->on_other = on_other;  
    53. 
  
  
  
  53.     impl_point->on_disconnect = on_disconnect;  
    54. 
  
  
  
  54.     impl_point->on_destroy = on_destroy;  
    55. 
  
  
  
  55.  
    56. 
  
  
  
  56.     return impl_point;  
    57. 
  
  
  
  57. } 
    58.

完整定义.

在example目录中，你可以看到聊天室演示chatroom 和在线白板示范whiteboard .

 
 
 
    
  
  
  
  1. #include   
    2. 
  
  
  
  2. #include   
    3. 
  
  
  
  3. #include   
    4. 
  
  
  
  4.    
    5. 
  
  
  
  5. #include   
    6. 
  
  
  
  6.    
    7. 
  
  
  
  7. #include "../endpoint_impl.h"  
    8. 
  
  
  
  8.    
    9. 
  
  
  
  9. typedef struct {  
    10. 
  
  
  
  10. char *event_name;  
    11. 
  
  
  
  11. char *event_args;  
    12. 
  
  
  
  12. } event_message;  
    13. 
  
  
  
  13.    
    14. 
  
  
  
  14. static char *event_message_reg = "{\"name\":\"(.*?)\",\"args\":\\[([^\\]]*?)\\]}";  
    15. 
  
  
  
  15.    
    16. 
  
  
  
  16. static gchar *get_match_result(GMatchInfo *match_info, gint index) {  
    17. 
  
  
  
  17. gchar *match = g_match_info_fetch(match_info, index);  
    18. 
  
  
  
  18. gchar *result = g_strdup(match);  
    19. 
  
  
  
  19. g_free(match);  
    20. 
  
  
  
  20.    
    21. 
  
  
  
  21. return result;  
    22. 
  
  
  
  22. }  
    23. 
  
  
  
  23.    
    24. 
  
  
  
  24. static void *message_2_struct(gchar *post_string, event_message *event_msg) {  
    25. 
  
  
  
  25. GError *error = NULL;  
    26. 
  
  
  
  26. GRegex *regex;  
    27. 
  
  
  
  27. GMatchInfo *match_info;  
    28. 
  
  
  
  28.    
    29. 
  
  
  
  29. regex = g_regex_new(event_message_reg, 0, 0, &error );  
    30. 
  
  
  
  30. g_regex_match( regex, post_string, 0, &match_info );  
    31. 
  
  
  
  31.    
    32. 
  
  
  
  32. if (g_match_info_matches(match_info)) {  
    33. 
  
  
  
  33. event_msg->event_name = get_match_result(match_info, 1);  
    34. 
  
  
  
  34. event_msg->event_args = get_match_result(match_info, 2);  
    35. 
  
  
  
  35. } else {  
    36. 
  
  
  
  36. event_msg = NULL;  
    37. 
  
  
  
  37. }  
    38. 
  
  
  
  38.    
    39. 
  
  
  
  39. g_match_info_free( match_info );  
    40. 
  
  
  
  40. g_regex_unref( regex );  
    41. 
  
  
  
  41.    
    42. 
  
  
  
  42. return event_msg;  
    43. 
  
  
  
  43. }  
    44. 
  
  
  
  44.    
    45. 
  
  
  
  45. static GHashTable *hashtable;  
    46. 
  
  
  
  46.    
    47. 
  
  
  
  47. static void hashtable_init(void) {  
    48. 
  
  
  
  48. hashtable = g_hash_table_new(g_str_hash, g_str_equal);  
    49. 
  
  
  
  49. }  
    50. 
  
  
  
  50.    
    51. 
  
  
  
  51. static void hashtable_add(const char *key, void *value) {  
    52. 
  
  
  
  52. if (key) {  
    53. 
  
  
  
  53. g_hash_table_insert(hashtable, g_strdup(key), value);  
    54. 
  
  
  
  54. }  
    55. 
  
  
  
  55. }  
    56. 
  
  
  
  56.    
    57. 
  
  
  
  57. static gboolean hashtable_remove(const char *key) {  
    58. 
  
  
  
  58. if (key)  
    59. 
  
  
  
  59. return g_hash_table_remove(hashtable, key);  
    60. 
  
  
  
  60.    
    61. 
  
  
  
  61. return 0;  
    62. 
  
  
  
  62. }  
    63. 
  
  
  
  63.    
    64. 
  
  
  
  64. static void *hashtable_lookup(const char *key) {  
    65. 
  
  
  
  65. if (key == NULL)  
    66. 
  
  
  
  66. return NULL;  
    67. 
  
  
  
  67. return g_hash_table_lookup(hashtable, key);  
    68. 
  
  
  
  68. }  
    69. 
  
  
  
  69.    
    70. 
  
  
  
  70. /*static gint hashtable_size(void) {  
    71. 
  
  
  
  71. return g_hash_table_size(hashtable);  
    72. 
  
  
  
  72. }*/ 
    73. 
  
  
  
  73.    
    74. 
  
  
  
  74. static void hashtable_destroy(void) {  
    75. 
  
  
  
  75. g_hash_table_destroy(hashtable);  
    76. 
  
  
  
  76. }  
    77. 
  
  
  
  77.    
    78. 
  
  
  
  78. /**  
    79. 
  
  
  
  79. ** use the struct to warpper the demo implment  
    80. 
  
  
  
  80. **/ 
    81. 
  
  
  
  81. static char *endpoint_name;  
    82. 
  
  
  
  82. static void on_init(const char *endpoint) {  
    83. 
  
  
  
  83. hashtable_init();  
    84. 
  
  
  
  84. printf("%s has been inited now\n", endpoint);  
    85. 
  
  
  
  85. endpoint_name = g_strdup(endpoint);  
    86. 
  
  
  
  86. }  
    87. 
  
  
  
  87.    
    88. 
  
  
  
  88. static void on_connect(const char *sessionid) {  
    89. 
  
  
  
  89. char messages[strlen(sessionid) + 50];  
    90. 
  
  
  
  90. sprintf(messages, "5::%s:{\"name\":\"clientId\",\"args\":[{\"id\":\"%s\"}]}", endpoint_name, sessionid);  
    91. 
  
  
  
  91.    
    92. 
  
  
  
  92. send_msg(sessionid, messages);  
    93. 
  
  
  
  93. }  
    94. 
  
  
  
  94.    
    95. 
  
  
  
  95. static void send_it(char *session_id, char *messaage) {  
    96. 
  
  
  
  96. send_msg(session_id, messaage);  
    97. 
  
  
  
  97. }  
    98. 
  
  
  
  98.    
    99. 
  
  
  
  99. static void free_event_msg(event_message *event_msg) {  
    100. 
  
  
  
  100. free(event_msg->event_name);  
    101. 
  
  
  
  101. free(event_msg->event_args);  
    102. 
  
  
  
  102. }  
    103. 
  
  
  
  103.    
    104. 
  
  
  
  104. static void on_event(const char *sessionid, const message_fields *msg_fields) {  
    105. 
  
  
  
  105. event_message event_msg;  
    106. 
  
  
  
  106. if (!message_2_struct(msg_fields->message_data, &event_msg)) {  
    107. 
  
  
  
  107. fprintf(stderr, "%s Parse Message Error !\n", msg_fields->ori_data);  
    108. 
  
  
  
  108. return;  
    109. 
  
  
  
  109. }  
    110. 
  
  
  
  110.    
    111. 
  
  
  
  111. if (!strcmp(event_msg.event_name, "roomNotice")) {  
    112. 
  
  
  
  112. /*5::/whiteboard:{"name":"roomNotice","args":[{"room":"myRoom"}]}*/ 
    113. 
  
  
  
  113. char target_room_id[strlen(event_msg.event_args) - 10];// = event_msg.event_args + 9;  
    114. 
  
  
  
  114. strncpy(target_room_id, event_msg.event_args + 9, strlen(event_msg.event_args) - 11);  
    115. 
  
  
  
  115.    
    116. 
  
  
  
  116. GPtrArray *list = (GPtrArray *)hashtable_lookup(target_room_id);  
    117. 
  
  
  
  117. if (list == NULL) {  
    118. 
  
  
  
  118. list = g_ptr_array_new();  
    119. 
  
  
  
  119. hashtable_add(target_room_id, list);  
    120. 
  
  
  
  120. }  
    121. 
  
  
  
  121. g_ptr_array_add(list, g_strdup(sessionid));  
    122. 
  
  
  
  122.    
    123. 
  
  
  
  123. int room_count = list->len;  
    124. 
  
  
  
  124. char messages[strlen(sessionid) + 200];  
    125. 
  
  
  
  125. sprintf(messages, "5::%s:{\"name\":\"roomCount\",\"args\":[{\"room\":\"%s\",\"num\":%d}]}", endpoint_name, target_room_id, room_count);  
    126. 
  
  
  
  126.    
    127. 
  
  
  
  127. hashtable_add(g_strdup(sessionid), g_strdup(target_room_id));  
    128. 
  
  
  
  128. g_ptr_array_foreach(list, (GFunc)send_it, messages);  
    129. 
  
  
  
  129. free_event_msg(&event_msg);  
    130. 
  
  
  
  130. return;  
    131. 
  
  
  
  131. }  
    132. 
  
  
  
  132.    
    133. 
  
  
  
  133. char messages[strlen(msg_fields->ori_data) + 200];  
    134. 
  
  
  
  134. sprintf(messages, "5::%s:{\"name\":\"%s\",\"args\":[%s]}", endpoint_name, event_msg.event_name, event_msg.event_args);  
    135. 
  
  
  
  135. free_event_msg(&event_msg);  
    136. 
  
  
  
  136. char *target_room_id = (char *)hashtable_lookup(sessionid);  
    137. 
  
  
  
  137. GPtrArray *list = (GPtrArray *)hashtable_lookup(target_room_id);  
    138. 
  
  
  
  138. if(list == NULL){  
    139. 
  
  
  
  139. return;  
    140. 
  
  
  
  140. }  
    141. 
  
  
  
  141.    
    142. 
  
  
  
  142. int i;  
    143. 
  
  
  
  143. for (i = 0; i < list->len; i++) {  
    144. 
  
  
  
  144. char *session_id = g_ptr_array_index(list, i);  
    145. 
  
  
  
  145. if (strcmp(session_id, sessionid) == 0)  
    146. 
  
  
  
  146. continue;  
    147. 
  
  
  
  147.    
    148. 
  
  
  
  148. send_msg(session_id, messages);  
    149. 
  
  
  
  149. }  
    150. 
  
  
  
  150.    
    151. 
  
  
  
  151. }  
    152. 
  
  
  
  152.    
    153. 
  
  
  
  153. static void on_disconnect(const char *sessionid, const message_fields *msg_fields) {  
    154. 
  
  
  
  154. char *room_id = (char *)hashtable_lookup(sessionid);  
    155. 
  
  
  
  155. if (room_id == NULL) {  
    156. 
  
  
  
  156. fprintf(stderr, "the room_id is NULL\n");  
    157. 
  
  
  
  157. return;  
    158. 
  
  
  
  158. }  
    159. 
  
  
  
  159.    
    160. 
  
  
  
  160. char notice_msg[strlen(endpoint_name) + strlen(room_id) + 70];  
    161. 
  
  
  
  161. GPtrArray *list = (GPtrArray *)hashtable_lookup(room_id);  
    162. 
  
  
  
  162. sprintf(notice_msg, "5::%s:{\"name\":\"roomCount\",\"args\":[{\"room\":\"%s\",\"num\":%d}]}", endpoint_name, room_id, list->len - 1);  
    163. 
  
  
  
  163. int i, remove_index;  
    164. 
  
  
  
  164. for (i = 0; i < list->len; i++) {  
    165. 
  
  
  
  165. char *session_id = g_ptr_array_index(list, i);  
    166. 
  
  
  
  166. if (strcmp(session_id, sessionid) == 0) {  
    167. 
  
  
  
  167. remove_index = i;  
    168. 
  
  
  
  168. continue;  
    169. 
  
  
  
  169. }  
    170. 
  
  
  
  170.    
    171. 
  
  
  
  171. send_msg(session_id, notice_msg);  
    172. 
  
  
  
  172. }  
    173. 
  
  
  
  173. g_ptr_array_remove_index(list, remove_index);  
    174. 
  
  
  
  174.    
    175. 
  
  
  
  175. hashtable_remove(sessionid);  
    176. 
  
  
  
  176. free(room_id);  
    177. 
  
  
  
  177. }  
    178. 
  
  
  
  178.    
    179. 
  
  
  
  179. static void on_destroy(const char *endpoint) {  
    180. 
  
  
  
  180. printf("%s has been destroy now\n", endpoint);  
    181. 
  
  
  
  181. hashtable_destroy();  
    182. 
  
  
  
  182. free(endpoint_name);  
    183. 
  
  
  
  183. }  
    184. 
  
  
  
  184.    
    185. 
  
  
  
  185. extern endpoint_implement *init_whiteboard_endpoint_implement(char *endpoint_name) {  
    186. 
  
  
  
  186. return init_default_endpoint_implement(endpoint_name);  
    187. 
  
  
  
  187. } 
    188.

因为C语言中没有散列表，只好借助于成熟的glib库实现。

其它

项目不太成熟，期待大家的参与，您的建议、批评和指正，都是一种激励，再次表示感谢。

本文题目：纯C语言版本的socket.io服务器端实现
分享网址：http://www.shufengxianlan.com/qtweb/news44/550394.html

网站建设、网络推广公司-创新互联，是专注品牌与效果的网站制作，网络营销seo公司；服务项目有等

广告

声明：本网站发布的内容（图片、视频和文字）以用户投稿、用户转载内容为主，如果涉及侵权请尽快告知，我们将会在第一时间删除。文章观点不代表本网站立场，如需处理请联系客服。电话：028-86922220；邮箱：631063699@qq.com。内容未经允许不得转载，或转载时需注明来源： 创新互联

猜你还喜欢下面的内容

外贸网站建设知识

各行业网站

自贡电信机房　　 　合江网站建设　　 　成都服务器托管　　 　自适应网站建设　　 　香港云主机　　 　软文推广　　 　成都办公窗帘　　 　网络营销推广　　 　成都画册设计　　 　ssl数字证书　　 　网站建设费用　　 　贵安服务器托管　　 　成都网站营销推广　　 　成都网站运营维护　　 　成都棕树机房　　 　模板商城网站　　 　h5页面制作　　 　宜宾网站建设　　 　四川搅拌罐车　　 　无边发光字制作