Skip to content

Commit a8b4104

Browse files
author
blog.s135.com
committed
增加队列已满时，禁止写入处理
1 parent 344e10d commit a8b4104

1 file changed

Lines changed: 63 additions & 64 deletions

File tree

‎httpsqs.c‎

Lines changed: 63 additions & 64 deletions
Original file line numberDiff line numberDiff line change
@@ -138,7 +138,7 @@ static int httpsqs_read_putpos(const char* httpsqs_input_name)
138138
{
139139
int queue_value = 0;
140140
char *queue_value_tmp;
141-
char *queue_name = (char *)malloc(300); /* 队列名称的总长度，用户输入的队列长度少于256字节 */
141+
char queue_name[300]; /* 队列名称的总长度，用户输入的队列长度少于256字节 */
142142
memset(queue_name, '\0', 300);
143143

144144
sprintf(queue_name, "%s:%s", httpsqs_input_name, "putpos");
@@ -148,7 +148,6 @@ static int httpsqs_read_putpos(const char* httpsqs_input_name)
148148
queue_value = atoi(queue_value_tmp);
149149
free(queue_value_tmp);
150150
}
151-
free(queue_name);
152151

153152
return queue_value;
154153
}
@@ -158,7 +157,7 @@ static int httpsqs_read_getpos(const char* httpsqs_input_name)
158157
{
159158
int queue_value = 0;
160159
char *queue_value_tmp;
161-
char *queue_name = (char *)malloc(300); /* 队列名称的总长度，用户输入的队列长度少于256字节 */
160+
char queue_name[300]; /* 队列名称的总长度，用户输入的队列长度少于256字节 */
162161
memset(queue_name, '\0', 300);
163162

164163
sprintf(queue_name, "%s:%s", httpsqs_input_name, "getpos");
@@ -168,7 +167,6 @@ static int httpsqs_read_getpos(const char* httpsqs_input_name)
168167
queue_value = atoi(queue_value_tmp);
169168
free(queue_value_tmp);
170169
}
171-
free(queue_name);
172170

173171
return queue_value;
174172
}
@@ -178,7 +176,7 @@ static int httpsqs_read_maxqueue(const char* httpsqs_input_name)
178176
{
179177
int queue_value = 0;
180178
char *queue_value_tmp;
181-
char *queue_name = (char *)malloc(300); /* 队列名称的总长度，用户输入的队列长度少于256字节 */
179+
char queue_name[300]; /* 队列名称的总长度，用户输入的队列长度少于256字节 */
182180
memset(queue_name, '\0', 300);
183181

184182
sprintf(queue_name, "%s:%s", httpsqs_input_name, "maxqueue");
@@ -190,7 +188,6 @@ static int httpsqs_read_maxqueue(const char* httpsqs_input_name)
190188
} else {
191189
queue_value = 1000000; /* 默认队列长度为100万条 */
192190
}
193-
free(queue_name);
194191

195192
return queue_value;
196193
}
@@ -213,14 +210,14 @@ static int httpsqs_maxqueue(const char* httpsqs_input_name, int httpsqs_input_nu
213210

214211
/* 设置的最大的队列数量必须大于等于”当前队列写入位置点“和”当前队列读取位置点“，并且”当前队列写入位置点“必须大于等于”当前队列读取位置点“ */
215212
if (queue_maxnum_int >= queue_put_value && queue_maxnum_int >= queue_get_value && queue_put_value >= queue_get_value) {
216-
char *queue_name = (char *)malloc(300); /* 队列名称的总长度，用户输入的队列长度少于256字节 */
213+
char queue_name[300]; /* 队列名称的总长度，用户输入的队列长度少于256字节 */
217214
char *queue_maxnum = (char *)malloc(16);
218215
memset(queue_name, '\0', 300);
219216
memset(queue_maxnum, '\0', 16);
220217
sprintf(queue_name, "%s:%s", httpsqs_input_name, "maxqueue");
221218
sprintf(queue_maxnum, "%d", queue_maxnum_int);
222219
tcbdbput2(httpsqs_db_tcbdb, queue_name, queue_maxnum);
223-
free(queue_name);
220+
224221
free(queue_maxnum);
225222
return queue_maxnum_int;
226223
}
@@ -231,7 +228,7 @@ static int httpsqs_maxqueue(const char* httpsqs_input_name, int httpsqs_input_nu
231228
/* 重置队列，0表示重置成功 */
232229
static int httpsqs_reset(const char* httpsqs_input_name)
233230
{
234-
char *queue_name = (char *)malloc(300); /* 队列名称的总长度，用户输入的队列长度少于256字节 */
231+
char queue_name[300]; /* 队列名称的总长度，用户输入的队列长度少于256字节 */
235232

236233
memset(queue_name, '\0', 300);
237234
sprintf(queue_name, "%s:%s", httpsqs_input_name, "putpos");
@@ -245,22 +242,19 @@ static int httpsqs_reset(const char* httpsqs_input_name)
245242
sprintf(queue_name, "%s:%s", httpsqs_input_name, "maxqueue");
246243
tcbdbout2(httpsqs_db_tcbdb, queue_name);
247244

248-
free(queue_name);
249-
250245
return 0;
251246
}
252247

253248
/* 查看单条队列内容 */
254249
char *httpsqs_view(const char* httpsqs_input_name, int pos)
255250
{
256251
char *queue_value;
257-
char *queue_name = (char *)malloc(300); /* 队列名称的总长度，用户输入的队列长度少于256字节 */
252+
char queue_name[300]; /* 队列名称的总长度，用户输入的队列长度少于256字节 */
258253
memset(queue_name, '\0', 300);
259254

260255
sprintf(queue_name, "%s:%d", httpsqs_input_name, pos);
261256

262257
queue_value = tcbdbget2(httpsqs_db_tcbdb, queue_name);
263-
free(queue_name);
264258

265259
return queue_value;
266260
}
@@ -269,38 +263,40 @@ char *httpsqs_view(const char* httpsqs_input_name, int pos)
269263
static int httpsqs_now_putpos(const char* httpsqs_input_name)
270264
{
271265
int maxqueue_num = 0;
272-
int queue_value = 0;
273-
char *queue_name = (char *)malloc(300); /* 队列名称的总长度，用户输入的队列长度少于256字节 */
266+
int queue_put_value = 0;
267+
int queue_get_value = 0;
268+
char queue_name[300]; /* 队列名称的总长度，用户输入的队列长度少于256字节 */
274269
char *queue_input = (char *)malloc(32);
275270

276271
/* 获取最大队列数量 */
277272
maxqueue_num = httpsqs_read_maxqueue(httpsqs_input_name);
278273

279274
/* 读取当前队列写入位置点 */
280-
queue_value = httpsqs_read_putpos(httpsqs_input_name);
275+
queue_put_value = httpsqs_read_putpos(httpsqs_input_name);
276+
277+
/* 读取当前队列读取位置点 */
278+
queue_get_value = httpsqs_read_getpos(httpsqs_input_name);
281279

282280
memset(queue_name, '\0', 300);
283281
sprintf(queue_name, "%s:%s", httpsqs_input_name, "putpos");
284282

285283
/* 队列写入位置点加1 */
286-
queue_value = queue_value + 1;
287-
if (queue_value > maxqueue_num) { /* 如果队列ID大于最大队列数量，则重置队列写入位置点的值为1 */
284+
queue_put_value = queue_put_value + 1;
285+
if (queue_put_value == queue_get_value) { /* 如果队列写入ID+1之后追上队列读取ID，则说明队列已满，返回0，拒绝继续写入 */
286+
queue_put_value = 0;
287+
}
288+
else if (queue_put_value > maxqueue_num) { /* 如果队列写入ID大于最大队列数量，则重置队列写入位置点的值为1 */
288289
if(tcbdbput2(httpsqs_db_tcbdb, queue_name, "1")) {
289-
queue_value = 1;
290-
memset(queue_name, '\0', 300);
291-
sprintf(queue_name, "%s:%s", httpsqs_input_name, "puttimes");
292-
tcbdbput2(httpsqs_db_tcbdb, queue_name, "yes"); /* 如果队列写入位置 */
290+
queue_put_value = 1;
293291
}
294292
} else { /* 队列写入位置点加1后的值，回写入数据库 */
295293
memset(queue_input, '\0', 32);
296-
sprintf(queue_input, "%d", queue_value);
294+
sprintf(queue_input, "%d", queue_put_value);
297295
tcbdbput2(httpsqs_db_tcbdb, queue_name, queue_input);
298296
free(queue_input);
299297
}
300298

301-
free(queue_name);
302-
303-
return queue_value;
299+
return queue_put_value;
304300
}
305301

306302
/* 获取本次“出队列”操作的队列读取点，返回值为0时队列全部读取完成 */
@@ -309,7 +305,7 @@ static int httpsqs_now_getpos(const char* httpsqs_input_name)
309305
int maxqueue_num = 0;
310306
int queue_put_value = 0;
311307
int queue_get_value = 0;
312-
char *queue_name = (char *)malloc(300); /* 队列名称的总长度，用户输入的队列长度少于256字节 */
308+
char queue_name[300]; /* 队列名称的总长度，用户输入的队列长度少于256字节 */
313309

314310
/* 获取最大队列数量 */
315311
maxqueue_num = httpsqs_read_maxqueue(httpsqs_input_name);
@@ -352,8 +348,6 @@ static int httpsqs_now_getpos(const char* httpsqs_input_name)
352348
queue_get_value = 0;
353349
}
354350

355-
free(queue_name);
356-
357351
return queue_get_value;
358352
}
359353

@@ -407,42 +401,48 @@ void httpsqs_handler(struct evhttp_request *req, void *arg)
407401
buffer_data_len = EVBUFFER_LENGTH(req->input_buffer);
408402
if (buffer_data_len > 0) {
409403
int queue_put_value = httpsqs_now_putpos((char *)httpsqs_input_name);
410-
char *queue_name = (char *)malloc(300); /* 队列名称的总长度，用户输入的队列长度少于256字节 */
411-
memset(queue_name, '\0', 300);
412-
sprintf(queue_name, "%s:%d", httpsqs_input_name, queue_put_value);
413-
char *httpsqs_input_postbuffer;
414-
char *buffer_data = (char *)malloc(buffer_data_len + 1);
415-
memset(buffer_data, '\0', buffer_data_len + 1);
416-
memcpy (buffer_data, EVBUFFER_DATA(req->input_buffer), buffer_data_len);
417-
httpsqs_input_postbuffer = urldecode(buffer_data);
418-
tcbdbput2(httpsqs_db_tcbdb, queue_name, httpsqs_input_postbuffer);
419-
memset(queue_name, '\0', 300);
420-
sprintf(queue_name, "%d", queue_put_value);
421-
evhttp_add_header(req->output_headers, "Pos", queue_name);
422-
evbuffer_add_printf(buf, "%s", "HTTPSQS_PUT_OK");
423-
free(queue_name);
424-
free(httpsqs_input_postbuffer);
425-
free(buffer_data);
404+
if (queue_put_value > 0) {
405+
char queue_name[300]; /* 队列名称的总长度，用户输入的队列长度少于256字节 */
406+
memset(queue_name, '\0', 300);
407+
sprintf(queue_name, "%s:%d", httpsqs_input_name, queue_put_value);
408+
char *httpsqs_input_postbuffer;
409+
char *buffer_data = (char *)malloc(buffer_data_len + 1);
410+
memset(buffer_data, '\0', buffer_data_len + 1);
411+
memcpy (buffer_data, EVBUFFER_DATA(req->input_buffer), buffer_data_len);
412+
httpsqs_input_postbuffer = urldecode(buffer_data);
413+
tcbdbput2(httpsqs_db_tcbdb, queue_name, httpsqs_input_postbuffer);
414+
memset(queue_name, '\0', 300);
415+
sprintf(queue_name, "%d", queue_put_value);
416+
evhttp_add_header(req->output_headers, "Pos", queue_name);
417+
evbuffer_add_printf(buf, "%s", "HTTPSQS_PUT_OK");
418+
free(httpsqs_input_postbuffer);
419+
free(buffer_data);
420+
} else {
421+
evbuffer_add_printf(buf, "%s", "HTTPSQS_PUT_END");
422+
}
426423
/* 如果POST正文无内容，则取URL中data参数的值 */
427424
} else if (httpsqs_input_data != NULL) {
428425
int queue_put_value = httpsqs_now_putpos((char *)httpsqs_input_name);
429-
char *queue_name = (char *)malloc(300); /* 队列名称的总长度，用户输入的队列长度少于256字节 */
430-
memset(queue_name, '\0', 300);
431-
sprintf(queue_name, "%s:%d", httpsqs_input_name, queue_put_value);
432-
buffer_data_len = strlen(httpsqs_input_data);
433-
char *httpsqs_input_postbuffer;
434-
char *buffer_data = (char *)malloc(buffer_data_len + 1);
435-
memset(buffer_data, '\0', buffer_data_len + 1);
436-
memcpy (buffer_data, httpsqs_input_data, buffer_data_len);
437-
httpsqs_input_postbuffer = urldecode(buffer_data);
438-
tcbdbput2(httpsqs_db_tcbdb, queue_name, buffer_data);
439-
memset(queue_name, '\0', 300);
440-
sprintf(queue_name, "%d", queue_put_value);
441-
evhttp_add_header(req->output_headers, "Pos", queue_name);
442-
evbuffer_add_printf(buf, "%s", "HTTPSQS_PUT_OK");
443-
free(queue_name);
444-
free(httpsqs_input_postbuffer);
445-
free(buffer_data);
426+
if (queue_put_value > 0) {
427+
char queue_name[300]; /* 队列名称的总长度，用户输入的队列长度少于256字节 */
428+
memset(queue_name, '\0', 300);
429+
sprintf(queue_name, "%s:%d", httpsqs_input_name, queue_put_value);
430+
buffer_data_len = strlen(httpsqs_input_data);
431+
char *httpsqs_input_postbuffer;
432+
char *buffer_data = (char *)malloc(buffer_data_len + 1);
433+
memset(buffer_data, '\0', buffer_data_len + 1);
434+
memcpy (buffer_data, httpsqs_input_data, buffer_data_len);
435+
httpsqs_input_postbuffer = urldecode(buffer_data);
436+
tcbdbput2(httpsqs_db_tcbdb, queue_name, buffer_data);
437+
memset(queue_name, '\0', 300);
438+
sprintf(queue_name, "%d", queue_put_value);
439+
evhttp_add_header(req->output_headers, "Pos", queue_name);
440+
evbuffer_add_printf(buf, "%s", "HTTPSQS_PUT_OK");
441+
free(httpsqs_input_postbuffer);
442+
free(buffer_data);
443+
} else {
444+
evbuffer_add_printf(buf, "%s", "HTTPSQS_PUT_END");
445+
}
446446
} else {
447447
evbuffer_add_printf(buf, "%s", "HTTPSQS_PUT_ERROR");
448448
}
@@ -454,7 +454,7 @@ void httpsqs_handler(struct evhttp_request *req, void *arg)
454454
if (queue_get_value == 0) {
455455
evbuffer_add_printf(buf, "%s", "HTTPSQS_GET_END");
456456
} else {
457-
char *queue_name = (char *)malloc(300); /* 队列名称的总长度，用户输入的队列长度少于256字节 */
457+
char queue_name[300]; /* 队列名称的总长度，用户输入的队列长度少于256字节 */
458458
memset(queue_name, '\0', 300);
459459
sprintf(queue_name, "%s:%d", httpsqs_input_name, queue_get_value);
460460
char *httpsqs_output_value;
@@ -468,7 +468,6 @@ void httpsqs_handler(struct evhttp_request *req, void *arg)
468468
} else {
469469
evbuffer_add_printf(buf, "%s", "HTTPSQS_GET_END");
470470
}
471-
free(queue_name);
472471
}
473472
}
474473
/* 查看队列状态 */

0 commit comments

Comments
 (0)