agoo 2.6.1 → 2.7.0
Sign up to get free protection for your applications and to get access to all the features.
Potentially problematic release.
This version of agoo might be problematic. Click here for more details.
- checksums.yaml +4 -4
- data/CHANGELOG.md +8 -0
- data/ext/agoo/agoo.c +5 -1
- data/ext/agoo/bind.c +17 -18
- data/ext/agoo/con.c +14 -7
- data/ext/agoo/debug.c +113 -63
- data/ext/agoo/debug.h +3 -0
- data/ext/agoo/err.c +7 -0
- data/ext/agoo/err.h +4 -0
- data/ext/agoo/error_stream.c +6 -0
- data/ext/agoo/gqleval.c +1 -1
- data/ext/agoo/gqlvalue.c +10 -11
- data/ext/agoo/graphql.c +181 -105
- data/ext/agoo/graphql.h +9 -0
- data/ext/agoo/hook.c +17 -7
- data/ext/agoo/log.c +8 -10
- data/ext/agoo/log.h +1 -1
- data/ext/agoo/page.c +242 -31
- data/ext/agoo/page.h +4 -3
- data/ext/agoo/queue.c +10 -7
- data/ext/agoo/queue.h +3 -2
- data/ext/agoo/ready.c +8 -7
- data/ext/agoo/rgraphql.c +29 -25
- data/ext/agoo/rlog.c +2 -2
- data/ext/agoo/rresponse.c +6 -0
- data/ext/agoo/rserver.c +49 -8
- data/ext/agoo/sdl.c +82 -35
- data/ext/agoo/sdl.h +3 -1
- data/ext/agoo/server.c +10 -6
- data/ext/agoo/server.h +2 -1
- data/ext/agoo/upgraded.c +2 -3
- data/lib/agoo/version.rb +1 -1
- data/test/static_test.rb +6 -1
- metadata +2 -2
checksums.yaml
CHANGED
@@ -1,7 +1,7 @@
|
|
1
1
|
---
|
2
2
|
SHA256:
|
3
|
-
metadata.gz:
|
4
|
-
data.tar.gz:
|
3
|
+
metadata.gz: 8a78c4278726e4fc90aad77fa83029fdfa2cbdf84d72796947ae5c22d30165e1
|
4
|
+
data.tar.gz: 8a3eb7eca852c6811270b7a6697a94184675e231f88f7c35848431b8495c166b
|
5
5
|
SHA512:
|
6
|
-
metadata.gz:
|
7
|
-
data.tar.gz:
|
6
|
+
metadata.gz: bc450f5bd00d4f256ddd31ccd29ad0075093403e41ff9d1bde7f3924796a32600ac9b6032452989f56b84303b44ee4f5663adce6d09eb3908cc2eef38b337f5e
|
7
|
+
data.tar.gz: a66662a930ec96e99ac91a15981add0ea63a484df8d0e488e6915e2f4ca7c55cb939c5775f0619e64dea87f2a9b2fdd6d311bcc31338d72693bc230c45b8fbdc
|
data/CHANGELOG.md
CHANGED
data/ext/agoo/agoo.c
CHANGED
@@ -90,7 +90,6 @@ sig_handler(int sig) {
|
|
90
90
|
exit(0);
|
91
91
|
}
|
92
92
|
|
93
|
-
|
94
93
|
/* Document-module: Agoo
|
95
94
|
*
|
96
95
|
* A High Performance HTTP Server that supports the Ruby rack API. The word
|
@@ -116,4 +115,9 @@ Init_agoo() {
|
|
116
115
|
signal(SIGINT, sig_handler);
|
117
116
|
signal(SIGTERM, sig_handler);
|
118
117
|
signal(SIGPIPE, SIG_IGN);
|
118
|
+
|
119
|
+
// This causes sleeps and queue pops to return immediately and is can be
|
120
|
+
// called all the time on mac OS with multiple threads. Something seems to
|
121
|
+
// get stuck.
|
122
|
+
signal(SIGVTALRM, SIG_IGN);
|
119
123
|
}
|
data/ext/agoo/bind.c
CHANGED
@@ -15,18 +15,18 @@
|
|
15
15
|
|
16
16
|
agooBind
|
17
17
|
agoo_bind_port(agooErr err, int port) {
|
18
|
-
agooBind b = (agooBind)
|
18
|
+
agooBind b = (agooBind)AGOO_CALLOC(1, sizeof(struct _agooBind));
|
19
19
|
|
20
20
|
if (NULL != b) {
|
21
21
|
char id[1024];
|
22
22
|
|
23
|
-
memset(b, 0, sizeof(struct _agooBind));
|
24
23
|
b->port = port;
|
25
24
|
b->family = AF_INET;
|
26
25
|
snprintf(id, sizeof(id) - 1, "http://:%d", port);
|
27
26
|
strcpy(b->scheme, "http");
|
28
27
|
if (NULL == (b->id = AGOO_STRDUP(id))) {
|
29
|
-
|
28
|
+
AGOO_ERR_MEM(err, "strdup()");
|
29
|
+
AGOO_FREE(b);
|
30
30
|
return NULL;
|
31
31
|
}
|
32
32
|
b->kind = AGOO_CON_HTTP;
|
@@ -62,17 +62,16 @@ url_tcp(agooErr err, const char *url, const char *scheme) {
|
|
62
62
|
}
|
63
63
|
port = atoi(colon + 1);
|
64
64
|
}
|
65
|
-
if (NULL != (b = (agooBind)
|
65
|
+
if (NULL != (b = (agooBind)AGOO_CALLOC(1, sizeof(struct _agooBind)))) {
|
66
66
|
char id[64];
|
67
|
-
|
68
|
-
memset(b, 0, sizeof(struct _agooBind));
|
69
67
|
|
70
68
|
b->port = port;
|
71
69
|
b->addr4 = addr;
|
72
70
|
b->family = AF_INET;
|
73
71
|
snprintf(id, sizeof(id), "%s://%s:%d", scheme, inet_ntoa(addr), port);
|
74
72
|
if (NULL == (b->id = AGOO_STRDUP(id))) {
|
75
|
-
|
73
|
+
AGOO_ERR_MEM(err, "strdup()");
|
74
|
+
AGOO_FREE(b);
|
76
75
|
return NULL;
|
77
76
|
}
|
78
77
|
strncpy(b->scheme, scheme, sizeof(b->scheme));
|
@@ -84,7 +83,7 @@ url_tcp(agooErr err, const char *url, const char *scheme) {
|
|
84
83
|
|
85
84
|
return b;
|
86
85
|
}
|
87
|
-
|
86
|
+
AGOO_ERR_MEM(err, "Bind");
|
88
87
|
|
89
88
|
return b;
|
90
89
|
}
|
@@ -107,17 +106,16 @@ url_tcp6(agooErr err, const char *url, const char *scheme) {
|
|
107
106
|
agoo_err_set(err, AGOO_ERR_ARG, "%s bind address is not valid. (%s)", scheme, url);
|
108
107
|
return NULL;
|
109
108
|
}
|
110
|
-
if (NULL != (b = (agooBind)
|
109
|
+
if (NULL != (b = (agooBind)AGOO_CALLOC(1, sizeof(struct _agooBind)))) {
|
111
110
|
char str[INET6_ADDRSTRLEN + 1];
|
112
|
-
|
113
|
-
memset(b, 0, sizeof(struct _agooBind));
|
114
111
|
|
115
112
|
b->port = port;
|
116
113
|
b->addr6 = addr;
|
117
114
|
b->family = AF_INET6;
|
118
115
|
snprintf(buf, sizeof(buf), "%s://[%s]:%d", scheme, inet_ntop(AF_INET6, &addr, str, INET6_ADDRSTRLEN), port);
|
119
116
|
if (NULL == (b->id = AGOO_STRDUP(buf))) {
|
120
|
-
|
117
|
+
AGOO_ERR_MEM(err, "strdup()");
|
118
|
+
AGOO_FREE(b);
|
121
119
|
return NULL;
|
122
120
|
}
|
123
121
|
strncpy(b->scheme, scheme, sizeof(b->scheme));
|
@@ -129,7 +127,7 @@ url_tcp6(agooErr err, const char *url, const char *scheme) {
|
|
129
127
|
|
130
128
|
return b;
|
131
129
|
}
|
132
|
-
|
130
|
+
AGOO_ERR_MEM(err, "Bind");
|
133
131
|
|
134
132
|
return b;
|
135
133
|
}
|
@@ -140,20 +138,21 @@ url_named(agooErr err, const char *url) {
|
|
140
138
|
agoo_err_set(err, AGOO_ERR_ARG, "Named Unix sockets names must not be empty.");
|
141
139
|
return NULL;
|
142
140
|
} else {
|
143
|
-
agooBind b = (agooBind)
|
141
|
+
agooBind b = (agooBind)AGOO_CALLOC(1, sizeof(struct _agooBind));
|
144
142
|
|
145
143
|
if (NULL != b) {
|
146
144
|
const char *fmt = "unix://%s";
|
147
145
|
char id[1024];
|
148
146
|
|
149
|
-
memset(b, 0, sizeof(struct _agooBind));
|
150
147
|
if (NULL == (b->name = AGOO_STRDUP(url))) {
|
151
|
-
|
148
|
+
AGOO_ERR_MEM(err, "strdup()");
|
149
|
+
AGOO_FREE(b);
|
152
150
|
return NULL;
|
153
151
|
}
|
154
152
|
snprintf(id, sizeof(id) - 1, fmt, url);
|
155
153
|
if (NULL == (b->id = AGOO_STRDUP(id))) {
|
156
|
-
|
154
|
+
AGOO_ERR_MEM(err, "strdup()");
|
155
|
+
AGOO_FREE(b);
|
157
156
|
return NULL;
|
158
157
|
}
|
159
158
|
strcpy(b->scheme, "unix");
|
@@ -164,7 +163,7 @@ url_named(agooErr err, const char *url) {
|
|
164
163
|
}
|
165
164
|
return b;
|
166
165
|
}
|
167
|
-
|
166
|
+
AGOO_ERR_MEM(err, "Bind");
|
168
167
|
|
169
168
|
return NULL;
|
170
169
|
}
|
data/ext/agoo/con.c
CHANGED
@@ -58,10 +58,9 @@ agooCon
|
|
58
58
|
agoo_con_create(agooErr err, int sock, uint64_t id, agooBind b) {
|
59
59
|
agooCon c;
|
60
60
|
|
61
|
-
if (NULL == (c = (agooCon)
|
62
|
-
|
61
|
+
if (NULL == (c = (agooCon)AGOO_CALLOC(1, sizeof(struct _agooCon)))) {
|
62
|
+
AGOO_ERR_MEM(err, "Connection");
|
63
63
|
} else {
|
64
|
-
memset(c, 0, sizeof(struct _agooCon));
|
65
64
|
c->sock = sock;
|
66
65
|
c->id = id;
|
67
66
|
c->timeout = dtime() + CON_TIMEOUT;
|
@@ -89,6 +88,7 @@ agoo_con_destroy(agooCon c) {
|
|
89
88
|
}
|
90
89
|
if (NULL != c->up) {
|
91
90
|
agoo_upgraded_release_con(c->up);
|
91
|
+
|
92
92
|
c->up = NULL;
|
93
93
|
}
|
94
94
|
agoo_log_cat(&agoo_con_cat, "Connection %llu closed.", (unsigned long long)c->id);
|
@@ -955,7 +955,7 @@ process_pub_con(agooPub pub, agooConLoop loop) {
|
|
955
955
|
default:
|
956
956
|
break;
|
957
957
|
}
|
958
|
-
agoo_pub_destroy(pub);
|
958
|
+
agoo_pub_destroy(pub);
|
959
959
|
}
|
960
960
|
|
961
961
|
short
|
@@ -1212,20 +1212,27 @@ agoo_conloop_create(agooErr err, int id) {
|
|
1212
1212
|
agooConLoop loop;
|
1213
1213
|
|
1214
1214
|
if (NULL == (loop = (agooConLoop)AGOO_MALLOC(sizeof(struct _agooConLoop)))) {
|
1215
|
-
|
1215
|
+
AGOO_ERR_MEM(err, "connection thread");
|
1216
1216
|
} else {
|
1217
1217
|
int stat;
|
1218
1218
|
|
1219
1219
|
loop->next = NULL;
|
1220
|
-
agoo_queue_multi_init(&loop->pub_queue, 256, true, false)
|
1220
|
+
if (AGOO_ERR_OK != agoo_queue_multi_init(err, &loop->pub_queue, 256, true, false)) {
|
1221
|
+
AGOO_FREE(loop);
|
1222
|
+
return NULL;
|
1223
|
+
}
|
1221
1224
|
loop->id = id;
|
1222
1225
|
loop->res_head = NULL;
|
1223
1226
|
loop->res_tail = NULL;
|
1227
|
+
if (0 != pthread_mutex_init(&loop->lock, 0)) {
|
1228
|
+
AGOO_FREE(loop);
|
1229
|
+
agoo_err_no(err, "Failed to initialize loop mutex.");
|
1230
|
+
return NULL;
|
1231
|
+
}
|
1224
1232
|
if (0 != (stat = pthread_create(&loop->thread, NULL, agoo_con_loop, loop))) {
|
1225
1233
|
agoo_err_set(err, stat, "Failed to create connection loop. %s", strerror(stat));
|
1226
1234
|
return NULL;
|
1227
1235
|
}
|
1228
|
-
pthread_mutex_init(&loop->lock, 0);
|
1229
1236
|
}
|
1230
1237
|
return loop;
|
1231
1238
|
}
|
data/ext/agoo/debug.c
CHANGED
@@ -34,54 +34,92 @@ static const char mem_pad[] = "--- This is a memory pad and should not change un
|
|
34
34
|
void
|
35
35
|
agoo_alloc(const void *ptr, size_t size, const char *file, int line) {
|
36
36
|
Rec r = (Rec)malloc(sizeof(struct _rec));
|
37
|
-
|
38
|
-
r
|
39
|
-
|
40
|
-
|
41
|
-
|
42
|
-
|
43
|
-
|
44
|
-
|
45
|
-
|
37
|
+
|
38
|
+
if (NULL != r) {
|
39
|
+
r->ptr = ptr;
|
40
|
+
r->size = size;
|
41
|
+
r->file = file;
|
42
|
+
r->line = line;
|
43
|
+
pthread_mutex_lock(&lock);
|
44
|
+
r->next = recs;
|
45
|
+
recs = r;
|
46
|
+
pthread_mutex_unlock(&lock);
|
47
|
+
}
|
46
48
|
}
|
47
49
|
|
48
50
|
void*
|
49
51
|
agoo_malloc(size_t size, const char *file, int line) {
|
50
52
|
void *ptr = malloc(size + sizeof(mem_pad));
|
51
|
-
Rec r = (Rec)malloc(sizeof(struct _rec));
|
52
|
-
|
53
|
-
strcpy(((char*)ptr) + size, mem_pad);
|
54
|
-
r->ptr = ptr;
|
55
|
-
r->size = size;
|
56
|
-
r->file = file;
|
57
|
-
r->line = line;
|
58
|
-
pthread_mutex_lock(&lock);
|
59
|
-
r->next = recs;
|
60
|
-
recs = r;
|
61
|
-
pthread_mutex_unlock(&lock);
|
62
53
|
|
54
|
+
if (NULL != ptr) {
|
55
|
+
Rec r = (Rec)malloc(sizeof(struct _rec));
|
56
|
+
|
57
|
+
if (NULL != r) {
|
58
|
+
strcpy(((char*)ptr) + size, mem_pad);
|
59
|
+
r->ptr = ptr;
|
60
|
+
r->size = size;
|
61
|
+
r->file = file;
|
62
|
+
r->line = line;
|
63
|
+
pthread_mutex_lock(&lock);
|
64
|
+
r->next = recs;
|
65
|
+
recs = r;
|
66
|
+
pthread_mutex_unlock(&lock);
|
67
|
+
} else {
|
68
|
+
free(ptr);
|
69
|
+
ptr = NULL;
|
70
|
+
}
|
71
|
+
}
|
63
72
|
return ptr;
|
64
73
|
}
|
65
74
|
|
66
75
|
void*
|
67
|
-
|
68
|
-
void *ptr
|
69
|
-
|
70
|
-
|
71
|
-
|
72
|
-
|
73
|
-
|
74
|
-
if (
|
76
|
+
agoo_calloc(size_t count, size_t size, const char *file, int line) {
|
77
|
+
void *ptr;
|
78
|
+
|
79
|
+
size *= count;
|
80
|
+
if (NULL != (ptr = malloc(size + sizeof(mem_pad)))) {
|
81
|
+
Rec r = (Rec)malloc(sizeof(struct _rec));
|
82
|
+
|
83
|
+
if (NULL != r) {
|
84
|
+
memset(ptr, 0, size);
|
85
|
+
strcpy(((char*)ptr) + size, mem_pad);
|
75
86
|
r->ptr = ptr;
|
76
87
|
r->size = size;
|
77
88
|
r->file = file;
|
78
89
|
r->line = line;
|
79
|
-
|
90
|
+
pthread_mutex_lock(&lock);
|
91
|
+
r->next = recs;
|
92
|
+
recs = r;
|
93
|
+
pthread_mutex_unlock(&lock);
|
94
|
+
} else {
|
95
|
+
free(ptr);
|
96
|
+
ptr = NULL;
|
80
97
|
}
|
81
98
|
}
|
82
|
-
|
83
|
-
|
84
|
-
|
99
|
+
return ptr;
|
100
|
+
}
|
101
|
+
|
102
|
+
void*
|
103
|
+
agoo_realloc(void *orig, size_t size, const char *file, int line) {
|
104
|
+
void *ptr = realloc(orig, size + sizeof(mem_pad));
|
105
|
+
Rec r;
|
106
|
+
|
107
|
+
if (NULL != ptr) {
|
108
|
+
strcpy(((char*)ptr) + size, mem_pad);
|
109
|
+
pthread_mutex_lock(&lock);
|
110
|
+
for (r = recs; NULL != r; r = r->next) {
|
111
|
+
if (orig == r->ptr) {
|
112
|
+
r->ptr = ptr;
|
113
|
+
r->size = size;
|
114
|
+
r->file = file;
|
115
|
+
r->line = line;
|
116
|
+
break;
|
117
|
+
}
|
118
|
+
}
|
119
|
+
pthread_mutex_unlock(&lock);
|
120
|
+
if (NULL == r) {
|
121
|
+
printf("Realloc at %s:%d (%p) not allocated.\n", file, line, orig);
|
122
|
+
}
|
85
123
|
}
|
86
124
|
return ptr;
|
87
125
|
}
|
@@ -90,19 +128,26 @@ char*
|
|
90
128
|
agoo_strdup(const char *str, const char *file, int line) {
|
91
129
|
size_t size = strlen(str) + 1;
|
92
130
|
char *ptr = (char*)malloc(size + sizeof(mem_pad));
|
93
|
-
Rec r = (Rec)malloc(sizeof(struct _rec));
|
94
|
-
|
95
|
-
strcpy(ptr, str);
|
96
|
-
strcpy(((char*)ptr) + size, mem_pad);
|
97
|
-
r->ptr = (void*)ptr;
|
98
|
-
r->size = size;
|
99
|
-
r->file = file;
|
100
|
-
r->line = line;
|
101
|
-
pthread_mutex_lock(&lock);
|
102
|
-
r->next = recs;
|
103
|
-
recs = r;
|
104
|
-
pthread_mutex_unlock(&lock);
|
105
131
|
|
132
|
+
if (NULL != ptr) {
|
133
|
+
Rec r = (Rec)malloc(sizeof(struct _rec));
|
134
|
+
|
135
|
+
if (NULL != r) {
|
136
|
+
strcpy(ptr, str);
|
137
|
+
strcpy(((char*)ptr) + size, mem_pad);
|
138
|
+
r->ptr = (void*)ptr;
|
139
|
+
r->size = size;
|
140
|
+
r->file = file;
|
141
|
+
r->line = line;
|
142
|
+
pthread_mutex_lock(&lock);
|
143
|
+
r->next = recs;
|
144
|
+
recs = r;
|
145
|
+
pthread_mutex_unlock(&lock);
|
146
|
+
} else {
|
147
|
+
free(ptr);
|
148
|
+
ptr = NULL;
|
149
|
+
}
|
150
|
+
}
|
106
151
|
return ptr;
|
107
152
|
}
|
108
153
|
|
@@ -110,20 +155,27 @@ char*
|
|
110
155
|
agoo_strndup(const char *str, size_t len, const char *file, int line) {
|
111
156
|
size_t size = len + 1;
|
112
157
|
char *ptr = (char*)malloc(size + sizeof(mem_pad));
|
113
|
-
Rec r = (Rec)malloc(sizeof(struct _rec));
|
114
|
-
|
115
|
-
memcpy(ptr, str, len);
|
116
|
-
ptr[len] = '\0';
|
117
|
-
strcpy(((char*)ptr) + size, mem_pad);
|
118
|
-
r->ptr = (void*)ptr;
|
119
|
-
r->size = size;
|
120
|
-
r->file = file;
|
121
|
-
r->line = line;
|
122
|
-
pthread_mutex_lock(&lock);
|
123
|
-
r->next = recs;
|
124
|
-
recs = r;
|
125
|
-
pthread_mutex_unlock(&lock);
|
126
158
|
|
159
|
+
if (NULL != ptr) {
|
160
|
+
Rec r = (Rec)malloc(sizeof(struct _rec));
|
161
|
+
|
162
|
+
if (NULL != r) {
|
163
|
+
memcpy(ptr, str, len);
|
164
|
+
ptr[len] = '\0';
|
165
|
+
strcpy(((char*)ptr) + size, mem_pad);
|
166
|
+
r->ptr = (void*)ptr;
|
167
|
+
r->size = size;
|
168
|
+
r->file = file;
|
169
|
+
r->line = line;
|
170
|
+
pthread_mutex_lock(&lock);
|
171
|
+
r->next = recs;
|
172
|
+
recs = r;
|
173
|
+
pthread_mutex_unlock(&lock);
|
174
|
+
} else {
|
175
|
+
free(ptr);
|
176
|
+
ptr = NULL;
|
177
|
+
}
|
178
|
+
}
|
127
179
|
return ptr;
|
128
180
|
}
|
129
181
|
|
@@ -207,10 +259,8 @@ agoo_freed(void *ptr, const char *file, int line) {
|
|
207
259
|
|
208
260
|
void
|
209
261
|
agoo_free(void *ptr, const char *file, int line) {
|
210
|
-
|
211
|
-
|
212
|
-
free(ptr);
|
213
|
-
}
|
262
|
+
agoo_freed(ptr, file, line);
|
263
|
+
free(ptr);
|
214
264
|
}
|
215
265
|
|
216
266
|
#endif
|
@@ -228,8 +278,8 @@ update_reps(Rep reps, Rec r) {
|
|
228
278
|
break;
|
229
279
|
}
|
230
280
|
}
|
231
|
-
if (NULL == rp
|
232
|
-
rp = (Rep)malloc(sizeof(struct _rep))
|
281
|
+
if (NULL == rp &&
|
282
|
+
NULL != (rp = (Rep)malloc(sizeof(struct _rep)))) {
|
233
283
|
rp->size = r->size;
|
234
284
|
rp->file = r->file;
|
235
285
|
rp->line = r->line;
|
data/ext/agoo/debug.h
CHANGED
@@ -8,6 +8,7 @@
|
|
8
8
|
#ifdef MEM_DEBUG
|
9
9
|
|
10
10
|
#define AGOO_MALLOC(size) agoo_malloc(size, __FILE__, __LINE__)
|
11
|
+
#define AGOO_CALLOC(count, size) agoo_calloc(count, size, __FILE__, __LINE__)
|
11
12
|
#define AGOO_ALLOC(ptr, size) agoo_alloc(ptr, size, __FILE__, __LINE__)
|
12
13
|
#define AGOO_REALLOC(ptr, size) agoo_realloc(ptr, size, __FILE__, __LINE__)
|
13
14
|
#define AGOO_STRDUP(str) agoo_strdup(str, __FILE__, __LINE__)
|
@@ -18,6 +19,7 @@
|
|
18
19
|
#define AGOO_MEM_CHECK(ptr) agoo_mem_check(ptr, __FILE__, __LINE__)
|
19
20
|
|
20
21
|
extern void* agoo_malloc(size_t size, const char *file, int line);
|
22
|
+
extern void* agoo_calloc(size_t count, size_t size, const char *file, int line);
|
21
23
|
extern void* agoo_realloc(void *ptr, size_t size, const char *file, int line);
|
22
24
|
extern char* agoo_strdup(const char *str, const char *file, int line);
|
23
25
|
extern char* agoo_strndup(const char *str, size_t len, const char *file, int line);
|
@@ -29,6 +31,7 @@ extern void agoo_mem_check(void *ptr, const char *file, int line);
|
|
29
31
|
#else
|
30
32
|
|
31
33
|
#define AGOO_MALLOC(size) malloc(size)
|
34
|
+
#define AGOO_CALLOC(count, size) calloc(count, size)
|
32
35
|
#define AGOO_ALLOC(ptr, size) {}
|
33
36
|
#define AGOO_REALLOC(ptr, size) realloc(ptr, size)
|
34
37
|
#define AGOO_STRDUP(str) strdup(str)
|