agoo 2.15.7 → 2.15.8

Sign up to get free protection for your applications and to get access to all the features.
Files changed (10) hide show
  1. checksums.yaml +4 -4
  2. data/CHANGELOG.md +12 -0
  3. data/bin/agoo +47 -39
  4. data/ext/agoo/bind.c +209 -198
  5. data/ext/agoo/rgraphql.c +7 -4
  6. data/ext/agoo/rserver.c +689 -688
  7. data/ext/agoo/server.c +255 -253
  8. data/lib/agoo/version.rb +1 -1
  9. data/lib/rack/handler/agoo.rb +130 -128
  10. metadata +3 -3
data/ext/agoo/bind.c CHANGED
@@ -16,70 +16,76 @@
16
16
 
17
17
  agooBind
18
18
  agoo_bind_port(agooErr err, int port) {
19
- agooBind b = (agooBind)AGOO_CALLOC(1, sizeof(struct _agooBind));
19
+ agooBind b = (agooBind)AGOO_CALLOC(1, sizeof(struct _agooBind));
20
20
 
21
21
  if (NULL != b) {
22
- char id[1024];
23
-
24
- b->port = port;
25
- b->family = AF_INET;
26
- snprintf(id, sizeof(id) - 1, "http://:%d", port);
27
- if (NULL == (b->id = AGOO_STRDUP(id))) {
28
- AGOO_ERR_MEM(err, "strdup()");
29
- AGOO_FREE(b);
30
- return NULL;
31
- }
32
- b->kind = AGOO_CON_HTTP;
33
- b->read = NULL;
34
- b->write = NULL;
35
- b->events = NULL;
22
+ char id[1024];
23
+
24
+ b->port = port;
25
+ b->family = AF_INET;
26
+ snprintf(id, sizeof(id) - 1, "http://:%d", port);
27
+ if (NULL == (b->id = AGOO_STRDUP(id))) {
28
+ AGOO_ERR_MEM(err, "strdup()");
29
+ AGOO_FREE(b);
30
+ return NULL;
31
+ }
32
+ b->kind = AGOO_CON_HTTP;
33
+ b->read = NULL;
34
+ b->write = NULL;
35
+ b->events = NULL;
36
36
  }
37
37
  return b;
38
38
  }
39
39
 
40
40
  static agooBind
41
41
  url_tcp(agooErr err, const char *url, const char *scheme) {
42
- char *colon = index(url, ':');
43
- struct in_addr addr = { .s_addr = 0 };
44
- int port;
45
- agooBind b;
42
+ char *colon = index(url, ':');
43
+ struct in_addr addr = { .s_addr = 0 };
44
+ int port;
45
+ agooBind b;
46
46
 
47
- if (NULL == colon) {
48
- port = 80;
47
+ if (NULL == colon || '\0' == colon[1]) {
48
+ port = 80;
49
49
  } else if (15 < colon - url) {
50
- agoo_err_set(err, AGOO_ERR_ARG, "%s bind address is not valid, too long. (%s)", scheme, url);
51
- return NULL;
50
+ agoo_err_set(err, AGOO_ERR_ARG, "%s bind address is not valid, too long. (%s)", scheme, url);
51
+ return NULL;
52
52
  } else if (':' == *url) {
53
- port = atoi(colon + 1);
53
+ port = atoi(colon + 1);
54
+ } else if (0 == strncmp("localhost", url, 9)) {
55
+ if (0 == inet_aton("127.0.0.1", &addr)) {
56
+ agoo_err_set(err, AGOO_ERR_ARG, "%s bind address is not valid. (%s)", scheme, url);
57
+ return NULL;
58
+ }
59
+ port = atoi(colon + 1);
54
60
  } else {
55
- char buf[32];
56
-
57
- strncpy(buf, url, colon - url);
58
- buf[colon - url] = '\0';
59
- if (0 == inet_aton(buf, &addr)) {
60
- agoo_err_set(err, AGOO_ERR_ARG, "%s bind address is not valid. (%s)", scheme, url);
61
- return NULL;
62
- }
63
- port = atoi(colon + 1);
61
+ char buf[32];
62
+
63
+ strncpy(buf, url, colon - url);
64
+ buf[colon - url] = '\0';
65
+ if (0 == inet_aton(buf, &addr)) {
66
+ agoo_err_set(err, AGOO_ERR_ARG, "%s bind address is not valid. (%s)", scheme, url);
67
+ return NULL;
68
+ }
69
+ port = atoi(colon + 1);
64
70
  }
65
71
  if (NULL != (b = (agooBind)AGOO_CALLOC(1, sizeof(struct _agooBind)))) {
66
- char id[64];
67
-
68
- b->port = port;
69
- b->addr4 = addr;
70
- b->family = AF_INET;
71
- snprintf(id, sizeof(id), "%s://%s:%d", scheme, inet_ntoa(addr), port);
72
- if (NULL == (b->id = AGOO_STRDUP(id))) {
73
- AGOO_ERR_MEM(err, "strdup()");
74
- AGOO_FREE(b);
75
- return NULL;
76
- }
77
- b->kind = AGOO_CON_HTTP;
78
- b->read = NULL;
79
- b->write = NULL;
80
- b->events = NULL;
81
-
82
- return b;
72
+ char id[64];
73
+
74
+ b->port = port;
75
+ b->addr4 = addr;
76
+ b->family = AF_INET;
77
+ snprintf(id, sizeof(id), "%s://%s:%d", scheme, inet_ntoa(addr), port);
78
+ if (NULL == (b->id = AGOO_STRDUP(id))) {
79
+ AGOO_ERR_MEM(err, "strdup()");
80
+ AGOO_FREE(b);
81
+ return NULL;
82
+ }
83
+ b->kind = AGOO_CON_HTTP;
84
+ b->read = NULL;
85
+ b->write = NULL;
86
+ b->events = NULL;
87
+
88
+ return b;
83
89
  }
84
90
  AGOO_ERR_MEM(err, "Bind");
85
91
 
@@ -88,40 +94,40 @@ url_tcp(agooErr err, const char *url, const char *scheme) {
88
94
 
89
95
  static agooBind
90
96
  url_tcp6(agooErr err, const char *url, const char *scheme) {
91
- struct in6_addr addr;
92
- char *end = index(url, ']');
93
- int port = 80;
94
- char buf[256];
95
- agooBind b;
97
+ struct in6_addr addr;
98
+ char *end = index(url, ']');
99
+ int port = 80;
100
+ char buf[256];
101
+ agooBind b;
96
102
 
97
103
  if (':' == *(end + 1)) {
98
- port = atoi(end + 2);
104
+ port = atoi(end + 2);
99
105
  }
100
106
  memcpy(buf, url + 1, end - url - 1);
101
107
  buf[end - url - 1] = '\0';
102
108
  memset(&addr, 0, sizeof(addr));
103
109
  if (0 == inet_pton(AF_INET6, buf, &addr)) {
104
- agoo_err_set(err, AGOO_ERR_ARG, "%s bind address is not valid. (%s)", scheme, url);
105
- return NULL;
110
+ agoo_err_set(err, AGOO_ERR_ARG, "%s bind address is not valid. (%s)", scheme, url);
111
+ return NULL;
106
112
  }
107
113
  if (NULL != (b = (agooBind)AGOO_CALLOC(1, sizeof(struct _agooBind)))) {
108
- char str[INET6_ADDRSTRLEN + 1];
109
-
110
- b->port = port;
111
- b->addr6 = addr;
112
- b->family = AF_INET6;
113
- snprintf(buf, sizeof(buf), "%s://[%s]:%d", scheme, inet_ntop(AF_INET6, &addr, str, INET6_ADDRSTRLEN), port);
114
- if (NULL == (b->id = AGOO_STRDUP(buf))) {
115
- AGOO_ERR_MEM(err, "strdup()");
116
- AGOO_FREE(b);
117
- return NULL;
118
- }
119
- b->kind = AGOO_CON_HTTP;
120
- b->read = NULL;
121
- b->write = NULL;
122
- b->events = NULL;
123
-
124
- return b;
114
+ char str[INET6_ADDRSTRLEN + 1];
115
+
116
+ b->port = port;
117
+ b->addr6 = addr;
118
+ b->family = AF_INET6;
119
+ snprintf(buf, sizeof(buf), "%s://[%s]:%d", scheme, inet_ntop(AF_INET6, &addr, str, INET6_ADDRSTRLEN), port);
120
+ if (NULL == (b->id = AGOO_STRDUP(buf))) {
121
+ AGOO_ERR_MEM(err, "strdup()");
122
+ AGOO_FREE(b);
123
+ return NULL;
124
+ }
125
+ b->kind = AGOO_CON_HTTP;
126
+ b->read = NULL;
127
+ b->write = NULL;
128
+ b->events = NULL;
129
+
130
+ return b;
125
131
  }
126
132
  AGOO_ERR_MEM(err, "Bind");
127
133
 
@@ -131,32 +137,32 @@ url_tcp6(agooErr err, const char *url, const char *scheme) {
131
137
  static agooBind
132
138
  url_named(agooErr err, const char *url) {
133
139
  if ('\0' == *url) {
134
- agoo_err_set(err, AGOO_ERR_ARG, "Named Unix sockets names must not be empty.");
135
- return NULL;
140
+ agoo_err_set(err, AGOO_ERR_ARG, "Named Unix sockets names must not be empty.");
141
+ return NULL;
136
142
  } else {
137
- agooBind b = (agooBind)AGOO_CALLOC(1, sizeof(struct _agooBind));
138
-
139
- if (NULL != b) {
140
- const char *fmt = "unix://%s";
141
- char id[1024];
142
-
143
- if (NULL == (b->name = AGOO_STRDUP(url))) {
144
- AGOO_ERR_MEM(err, "strdup()");
145
- AGOO_FREE(b);
146
- return NULL;
147
- }
148
- snprintf(id, sizeof(id) - 1, fmt, url);
149
- if (NULL == (b->id = AGOO_STRDUP(id))) {
150
- AGOO_ERR_MEM(err, "strdup()");
151
- AGOO_FREE(b);
152
- return NULL;
153
- }
154
- b->kind = AGOO_CON_HTTP;
155
- b->read = NULL;
156
- b->write = NULL;
157
- b->events = NULL;
158
- }
159
- return b;
143
+ agooBind b = (agooBind)AGOO_CALLOC(1, sizeof(struct _agooBind));
144
+
145
+ if (NULL != b) {
146
+ const char *fmt = "unix://%s";
147
+ char id[1024];
148
+
149
+ if (NULL == (b->name = AGOO_STRDUP(url))) {
150
+ AGOO_ERR_MEM(err, "strdup()");
151
+ AGOO_FREE(b);
152
+ return NULL;
153
+ }
154
+ snprintf(id, sizeof(id) - 1, fmt, url);
155
+ if (NULL == (b->id = AGOO_STRDUP(id))) {
156
+ AGOO_ERR_MEM(err, "strdup()");
157
+ AGOO_FREE(b);
158
+ return NULL;
159
+ }
160
+ b->kind = AGOO_CON_HTTP;
161
+ b->read = NULL;
162
+ b->write = NULL;
163
+ b->events = NULL;
164
+ }
165
+ return b;
160
166
  }
161
167
  AGOO_ERR_MEM(err, "Bind");
162
168
 
@@ -165,56 +171,56 @@ url_named(agooErr err, const char *url) {
165
171
 
166
172
  static agooBind
167
173
  url_ssl(agooErr err, const char *url) {
168
- char *colon = index(url, ':');
169
- struct in_addr addr = { .s_addr = 0 };
170
- int port;
171
- agooBind b;
174
+ char *colon = index(url, ':');
175
+ struct in_addr addr = { .s_addr = 0 };
176
+ int port;
177
+ agooBind b;
172
178
 
173
179
  #ifdef HAVE_OPENSSL_SSL_H
174
180
  if (NULL == agoo_server.ssl_ctx) {
175
- agoo_err_set(err, AGOO_ERR_ARG, "https requires an SSL certificate and private key. (%s)", url);
176
- return NULL;
181
+ agoo_err_set(err, AGOO_ERR_ARG, "https requires an SSL certificate and private key. (%s)", url);
182
+ return NULL;
177
183
  }
178
184
  #else
179
185
  agoo_err_set(err, AGOO_ERR_ARG, "https requires OpenSSL. Rebuild with OpenSSL. (%s)", url);
180
186
  return NULL;
181
187
  #endif
182
188
  if (NULL == colon) {
183
- port = 443;
189
+ port = 443;
184
190
  } else if (15 < colon - url) {
185
- agoo_err_set(err, AGOO_ERR_ARG, "https bind address is not valid, too long. (%s)", url);
186
- return NULL;
191
+ agoo_err_set(err, AGOO_ERR_ARG, "https bind address is not valid, too long. (%s)", url);
192
+ return NULL;
187
193
  } else if (':' == *url) {
188
- port = atoi(colon + 1);
194
+ port = atoi(colon + 1);
189
195
  } else {
190
- char buf[32];
191
-
192
- strncpy(buf, url, colon - url);
193
- buf[colon - url] = '\0';
194
- if (0 == inet_aton(buf, &addr)) {
195
- agoo_err_set(err, AGOO_ERR_ARG, "https bind address is not valid. (%s)", url);
196
- return NULL;
197
- }
198
- port = atoi(colon + 1);
196
+ char buf[32];
197
+
198
+ strncpy(buf, url, colon - url);
199
+ buf[colon - url] = '\0';
200
+ if (0 == inet_aton(buf, &addr)) {
201
+ agoo_err_set(err, AGOO_ERR_ARG, "https bind address is not valid. (%s)", url);
202
+ return NULL;
203
+ }
204
+ port = atoi(colon + 1);
199
205
  }
200
206
  if (NULL != (b = (agooBind)AGOO_CALLOC(1, sizeof(struct _agooBind)))) {
201
- char id[64];
202
-
203
- b->port = port;
204
- b->addr4 = addr;
205
- b->family = AF_INET;
206
- snprintf(id, sizeof(id), "https://%s:%d", inet_ntoa(addr), port);
207
- if (NULL == (b->id = AGOO_STRDUP(id))) {
208
- AGOO_ERR_MEM(err, "strdup()");
209
- AGOO_FREE(b);
210
- return NULL;
211
- }
212
- b->kind = AGOO_CON_HTTPS;
213
- b->read = NULL;
214
- b->write = NULL;
215
- b->events = NULL;
216
-
217
- return b;
207
+ char id[64];
208
+
209
+ b->port = port;
210
+ b->addr4 = addr;
211
+ b->family = AF_INET;
212
+ snprintf(id, sizeof(id), "https://%s:%d", inet_ntoa(addr), port);
213
+ if (NULL == (b->id = AGOO_STRDUP(id))) {
214
+ AGOO_ERR_MEM(err, "strdup()");
215
+ AGOO_FREE(b);
216
+ return NULL;
217
+ }
218
+ b->kind = AGOO_CON_HTTPS;
219
+ b->read = NULL;
220
+ b->write = NULL;
221
+ b->events = NULL;
222
+
223
+ return b;
218
224
  }
219
225
  AGOO_ERR_MEM(err, "Bind");
220
226
 
@@ -224,41 +230,42 @@ url_ssl(agooErr err, const char *url) {
224
230
  agooBind
225
231
  agoo_bind_url(agooErr err, const char *url) {
226
232
  if (0 == strncasecmp("tcp://", url, 6)) {
227
- if ('[' == url[6]) {
228
- return url_tcp6(err, url + 6, "tcp");
229
- }
230
- return url_tcp(err, url + 6, "tcp");
233
+ if ('[' == url[6]) {
234
+ return url_tcp6(err, url + 6, "tcp");
235
+ }
236
+ return url_tcp(err, url + 6, "tcp");
231
237
  }
232
238
  if (0 == strncasecmp("http://", url, 7)) {
233
- if ('[' == url[7]) {
234
- return url_tcp6(err, url + 7, "http");
235
- }
236
- return url_tcp(err, url + 7, "http");
239
+ if ('[' == url[7]) {
240
+ return url_tcp6(err, url + 7, "http");
241
+ }
242
+ return url_tcp(err, url + 7, "http");
237
243
  }
238
244
  if (0 == strncasecmp("unix://", url, 7)) {
239
- return url_named(err, url + 7);
245
+ return url_named(err, url + 7);
240
246
  }
241
247
  if (0 == strncasecmp("https://", url, 8)) {
242
- return url_ssl(err, url + 8);
248
+ return url_ssl(err, url + 8);
243
249
  }
244
250
  if (0 == strncasecmp("ssl://", url, 6)) {
245
- return url_ssl(err, url + 6);
251
+ return url_ssl(err, url + 6);
246
252
  }
247
253
  // All others assume http
248
254
  {
249
- char *colon = index(url, ':');
250
- char scheme[8];
251
-
252
- if (NULL != colon && colon - url < (int)sizeof(scheme)) {
253
- int slen = (int)(colon - url);
254
-
255
- memcpy(scheme, url, slen);
256
- scheme[slen] = '\0';
257
- if ('[' == url[slen + 3]) {
258
- return url_tcp6(err, url + slen + 3, scheme);
259
- }
260
- return url_tcp(err, url + slen + 3, scheme);
261
- }
255
+ char *colon = index(url, ':');
256
+ char scheme[8];
257
+
258
+ if (NULL != colon && colon - url < (int)sizeof(scheme)) {
259
+ int slen = (int)(colon - url);
260
+
261
+ memcpy(scheme, url, slen);
262
+ scheme[slen] = '\0';
263
+ if ('[' == url[slen + 3]) {
264
+ return url_tcp6(err, url + slen + 3, scheme);
265
+ }
266
+ return url_tcp(err, url + slen + 3, scheme);
267
+ }
268
+ return url_tcp(err, url, "http");
262
269
  }
263
270
  return NULL;
264
271
  }
@@ -272,16 +279,17 @@ agoo_bind_destroy(agooBind b) {
272
279
 
273
280
  static int
274
281
  usual_listen(agooErr err, agooBind b) {
275
- int optval = 1;
276
- int domain = PF_INET;
282
+ int optval = 1;
283
+ int domain = PF_INET;
284
+ int e;
277
285
 
278
286
  if (AF_INET6 == b->family) {
279
- domain = PF_INET6;
287
+ domain = PF_INET6;
280
288
  }
281
289
  if (0 >= (b->fd = socket(domain, SOCK_STREAM, IPPROTO_TCP))) {
282
- agoo_log_cat(&agoo_error_cat, "Server failed to open server socket on port %d. %s.", b->port, strerror(errno));
290
+ agoo_log_cat(&agoo_error_cat, "Server failed to open server socket on port %d. %s.", b->port, strerror(errno));
283
291
 
284
- return agoo_err_set(err, errno, "Server failed to open server socket. %s.", strerror(errno));
292
+ return agoo_err_set(err, errno, "Server failed to open server socket. %s.", strerror(errno));
285
293
  }
286
294
  #ifdef OSX_OS
287
295
  setsockopt(b->fd, SOL_SOCKET, SO_NOSIGPIPE, &optval, sizeof(optval));
@@ -291,63 +299,66 @@ usual_listen(agooErr err, agooBind b) {
291
299
  #endif
292
300
  setsockopt(b->fd, IPPROTO_TCP, TCP_NODELAY, &optval, sizeof(optval));
293
301
  if (AF_INET6 == b->family) {
294
- struct sockaddr_in6 addr;
295
-
296
- memset(&addr, 0, sizeof(addr));
297
- addr.sin6_flowinfo = 0;
298
- addr.sin6_family = b->family;
299
- addr.sin6_addr = b->addr6;
300
- addr.sin6_port = htons(b->port);
301
- if (0 > bind(b->fd, (struct sockaddr*)&addr, sizeof(addr))) {
302
- agoo_log_cat(&agoo_error_cat, "Server failed to bind server socket. %s.", strerror(errno));
303
-
304
- return agoo_err_set(err, errno, "Server failed to bind server socket. %s.", strerror(errno));
305
- }
302
+ struct sockaddr_in6 addr;
303
+
304
+ memset(&addr, 0, sizeof(addr));
305
+ addr.sin6_flowinfo = 0;
306
+ addr.sin6_family = b->family;
307
+ addr.sin6_addr = b->addr6;
308
+ addr.sin6_port = htons(b->port);
309
+ if (0 > bind(b->fd, (struct sockaddr*)&addr, sizeof(addr))) {
310
+ agoo_log_cat(&agoo_error_cat, "Server failed to bind server socket. %s.", strerror(errno));
311
+
312
+ return agoo_err_set(err, errno, "Server failed to bind server socket. %s.", strerror(errno));
313
+ }
306
314
  } else {
307
- struct sockaddr_in addr;
315
+ struct sockaddr_in addr;
308
316
 
309
- memset(&addr, 0, sizeof(addr));
310
- addr.sin_family = b->family;
311
- addr.sin_addr = b->addr4;
312
- addr.sin_port = htons(b->port);
313
- if (0 > bind(b->fd, (struct sockaddr*)&addr, sizeof(addr))) {
314
- agoo_log_cat(&agoo_error_cat, "Server failed to bind server socket. %s.", strerror(errno));
317
+ memset(&addr, 0, sizeof(addr));
318
+ addr.sin_family = b->family;
319
+ addr.sin_addr = b->addr4;
320
+ addr.sin_port = htons(b->port);
321
+ if (0 > bind(b->fd, (struct sockaddr*)&addr, sizeof(addr))) {
322
+ agoo_log_cat(&agoo_error_cat, "Server failed to bind server socket. %s.", strerror(errno));
315
323
 
316
- return agoo_err_set(err, errno, "Server failed to bind server socket. %s.", strerror(errno));
317
- }
324
+ return agoo_err_set(err, errno, "Server failed to bind server socket. %s.", strerror(errno));
325
+ }
326
+ }
327
+ if (0 != (e = listen(b->fd, 1000))) {
328
+ return agoo_err_set(err, e, "Server failed to bind to port %d. %s.", b->fd, strerror(e));
318
329
  }
319
- listen(b->fd, 1000);
320
-
321
330
  return AGOO_ERR_OK;
322
331
  }
323
332
 
324
333
  static int
325
334
  named_listen(agooErr err, agooBind b) {
326
- struct sockaddr_un addr;
335
+ struct sockaddr_un addr;
336
+ int e;
327
337
 
328
338
  remove(b->name);
329
339
  if (0 >= (b->fd = socket(AF_UNIX, SOCK_STREAM, 0))) {
330
- agoo_log_cat(&agoo_error_cat, "Server failed to open server socket on %s. %s.", b->name, strerror(errno));
340
+ agoo_log_cat(&agoo_error_cat, "Server failed to open server socket on %s. %s.", b->name, strerror(errno));
331
341
 
332
- return agoo_err_set(err, errno, "Server failed to open server socket on %s. %s.", b->name, strerror(errno));
342
+ return agoo_err_set(err, errno, "Server failed to open server socket on %s. %s.", b->name, strerror(errno));
333
343
  }
334
344
  memset(&addr, 0, sizeof(addr));
335
345
  addr.sun_family = AF_UNIX;
336
346
  strcpy(addr.sun_path, b->name);
337
347
  if (0 > bind(b->fd, (struct sockaddr*)&addr, sizeof(addr))) {
338
- agoo_log_cat(&agoo_error_cat, "Server failed to bind server socket. %s.", strerror(errno));
348
+ agoo_log_cat(&agoo_error_cat, "Server failed to bind server socket. %s.", strerror(errno));
339
349
 
340
- return agoo_err_set(err, errno, "Server failed to bind server socket. %s.", strerror(errno));
350
+ return agoo_err_set(err, errno, "Server failed to bind server socket. %s.", strerror(errno));
351
+ }
352
+ if (0 != (e = listen(b->fd, 100))) {
353
+ return agoo_err_set(err, e, "Server failed to bind to port %d. %s.", b->fd, strerror(e));
341
354
  }
342
- listen(b->fd, 100);
343
-
344
355
  return AGOO_ERR_OK;
345
356
  }
346
357
 
347
358
  int
348
359
  agoo_bind_listen(agooErr err, agooBind b) {
349
360
  if (NULL != b->name) {
350
- return named_listen(err, b);
361
+ return named_listen(err, b);
351
362
  }
352
363
  return usual_listen(err, b);
353
364
  }
@@ -355,7 +366,7 @@ agoo_bind_listen(agooErr err, agooBind b) {
355
366
  void
356
367
  agoo_bind_close(agooBind b) {
357
368
  if (0 != b->fd) {
358
- close(b->fd);
359
- b->fd = 0;
369
+ close(b->fd);
370
+ b->fd = 0;
360
371
  }
361
372
  }
data/ext/agoo/rgraphql.c CHANGED
@@ -406,6 +406,9 @@ ref_type(gqlRef ref) {
406
406
  TypeClass tc;
407
407
  const char *classname = rb_obj_classname((VALUE)ref);
408
408
 
409
+ if (RUBY_T_ARRAY == rb_type((VALUE)ref) && 0 < RARRAY_LEN((VALUE)ref)) {
410
+ classname = rb_obj_classname(RARRAY_AREF((VALUE)ref, 0));
411
+ }
409
412
  for (tc = type_class_map; NULL != tc->type; tc++) {
410
413
  if (0 == strcmp(classname, tc->classname)) {
411
414
  type = tc->type;
@@ -436,8 +439,8 @@ resolve(agooErr err, gqlDoc doc, gqlRef target, gqlField field, gqlSel sel, gqlV
436
439
  ID method;
437
440
  int arity;
438
441
 
439
- if ('_' == *sel->name && '_' == sel->name[1]) {
440
- if (0 == strcmp("__typename", sel->name)) {
442
+ if ('_' == *key && '_' == key[1]) {
443
+ if (0 == strcmp("__typename", key)) {
441
444
  if (AGOO_ERR_OK != gql_set_typename(err, ref_type(target), key, result)) {
442
445
  return err->code;
443
446
  }
@@ -447,9 +450,9 @@ resolve(agooErr err, gqlDoc doc, gqlRef target, gqlField field, gqlSel sel, gqlV
447
450
  case GQL_QUERY:
448
451
  return gql_intro_eval(err, doc, sel, result, depth);
449
452
  case GQL_MUTATION:
450
- return agoo_err_set(err, AGOO_ERR_EVAL, "%s can not be called on a mutation.", sel->name);
453
+ return agoo_err_set(err, AGOO_ERR_EVAL, "%s can not be called on a mutation.", key);
451
454
  case GQL_SUBSCRIPTION:
452
- return agoo_err_set(err, AGOO_ERR_EVAL, "%s can not be called on a subscription.", sel->name);
455
+ return agoo_err_set(err, AGOO_ERR_EVAL, "%s can not be called on a subscription.", key);
453
456
  default:
454
457
  return agoo_err_set(err, AGOO_ERR_EVAL, "Not a valid operation on the root object.");
455
458
  }