Make use of new vdo().
[awesomized/libmemcached] / libmemcached / version.c
1 #include "common.h"
2
3 const char * memcached_lib_version(void)
4 {
5 return LIBMEMCACHED_VERSION_STRING;
6 }
7
8 static inline memcached_return_t memcached_version_binary(memcached_st *ptr);
9 static inline memcached_return_t memcached_version_textual(memcached_st *ptr);
10
11 memcached_return_t memcached_version(memcached_st *ptr)
12 {
13 if (ptr->flags.use_udp)
14 return MEMCACHED_NOT_SUPPORTED;
15
16 if (ptr->flags.binary_protocol)
17 return memcached_version_binary(ptr);
18 else
19 return memcached_version_textual(ptr);
20 }
21
22 static inline memcached_return_t memcached_version_textual(memcached_st *ptr)
23 {
24 size_t send_length;
25 memcached_return_t rc;
26 char buffer[MEMCACHED_DEFAULT_COMMAND_SIZE];
27 char *response_ptr;
28 const char *command= "version\r\n";
29
30 send_length= strlen(command);
31
32 rc= MEMCACHED_SUCCESS;
33 for (uint32_t x= 0; x < memcached_server_count(ptr); x++)
34 {
35 memcached_return_t rrc;
36 memcached_server_write_instance_st instance=
37 memcached_server_instance_fetch(ptr, x);
38
39 rrc= memcached_do(instance, command, send_length, true);
40 if (rrc != MEMCACHED_SUCCESS)
41 {
42 rc= MEMCACHED_SOME_ERRORS;
43 continue;
44 }
45
46 rrc= memcached_response(instance, buffer, MEMCACHED_DEFAULT_COMMAND_SIZE, NULL);
47 if (rrc != MEMCACHED_SUCCESS)
48 {
49 rc= MEMCACHED_SOME_ERRORS;
50 continue;
51 }
52
53 /* Find the space, and then move one past it to copy version */
54 response_ptr= index(buffer, ' ');
55 response_ptr++;
56
57 instance->major_version= (uint8_t)strtol(response_ptr, (char **)NULL, 10);
58 response_ptr= index(response_ptr, '.');
59 response_ptr++;
60 instance->minor_version= (uint8_t)strtol(response_ptr, (char **)NULL, 10);
61 response_ptr= index(response_ptr, '.');
62 response_ptr++;
63 instance->micro_version= (uint8_t)strtol(response_ptr, (char **)NULL, 10);
64 }
65
66 return rc;
67 }
68
69 static inline memcached_return_t memcached_version_binary(memcached_st *ptr)
70 {
71 memcached_return_t rc;
72 protocol_binary_request_version request= { .bytes= {0}};
73 request.message.header.request.magic= PROTOCOL_BINARY_REQ;
74 request.message.header.request.opcode= PROTOCOL_BINARY_CMD_VERSION;
75 request.message.header.request.datatype= PROTOCOL_BINARY_RAW_BYTES;
76
77 rc= MEMCACHED_SUCCESS;
78 for (uint32_t x= 0; x < memcached_server_count(ptr); x++)
79 {
80 memcached_return_t rrc;
81
82 memcached_server_write_instance_st instance=
83 memcached_server_instance_fetch(ptr, x);
84
85 rrc= memcached_do(instance, request.bytes, sizeof(request.bytes), true);
86 if (rrc != MEMCACHED_SUCCESS)
87 {
88 memcached_io_reset(instance);
89 rc= MEMCACHED_SOME_ERRORS;
90 continue;
91 }
92 }
93
94 for (uint32_t x= 0; x < memcached_server_count(ptr); x++)
95 {
96 memcached_server_write_instance_st instance=
97 memcached_server_instance_fetch(ptr, x);
98
99 if (memcached_server_response_count(instance) > 0)
100 {
101 memcached_return_t rrc;
102 char buffer[32];
103 char *p;
104
105 rrc= memcached_response(instance, buffer, sizeof(buffer), NULL);
106 if (rrc != MEMCACHED_SUCCESS)
107 {
108 memcached_io_reset(instance);
109 rc= MEMCACHED_SOME_ERRORS;
110 continue;
111 }
112
113 instance->major_version= (uint8_t)strtol(buffer, &p, 10);
114 instance->minor_version= (uint8_t)strtol(p + 1, &p, 10);
115 instance->micro_version= (uint8_t)strtol(p + 1, NULL, 10);
116 }
117 }
118
119 return rc;
120 }