![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to js_socket.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Synchronet] / sbbs / src / sbbs3|
Return to js_socket.c CVS log | Up to [Synchronet] / sbbs / src / sbbs3 |
1.1 root 1: /* js_socket.c */
2:
3: /* Synchronet JavaScript "Socket" Object */
4:
5: /* $Id: js_socket.c,v 1.118 2006/12/28 02:43:48 rswindell Exp $ */
6:
7: /****************************************************************************
8: * @format.tab-size 4 (Plain Text/Source Code File Header) *
9: * @format.use-tabs true (see http://www.synchro.net/ptsc_hdr.html) *
10: * *
11: * Copyright 2006 Rob Swindell - http://www.synchro.net/copyright.html *
12: * *
13: * This program is free software; you can redistribute it and/or *
14: * modify it under the terms of the GNU General Public License *
15: * as published by the Free Software Foundation; either version 2 *
16: * of the License, or (at your option) any later version. *
17: * See the GNU General Public License for more details: gpl.txt or *
18: * http://www.fsf.org/copyleft/gpl.html *
19: * *
20: * Anonymous FTP access to the most recent released source is available at *
21: * ftp://vert.synchro.net, ftp://cvs.synchro.net and ftp://ftp.synchro.net *
22: * *
23: * Anonymous CVS access to the development source and modification history *
24: * is available at cvs.synchro.net:/cvsroot/sbbs, example: *
25: * cvs -d :pserver:[email protected]:/cvsroot/sbbs login *
26: * (just hit return, no password is necessary) *
27: * cvs -d :pserver:[email protected]:/cvsroot/sbbs checkout src *
28: * *
29: * For Synchronet coding style and modification guidelines, see *
30: * http://www.synchro.net/source.html *
31: * *
32: * You are encouraged to submit any modifications (preferably in Unix diff *
33: * format) via e-mail to [email protected] *
34: * *
35: * Note: If this box doesn't appear square, then you need to fix your tabs. *
36: ****************************************************************************/
37:
38: #include "sbbs.h"
39:
40: #ifdef JAVASCRIPT
41:
42: typedef struct
43: {
44: SOCKET sock;
45: BOOL external; /* externally created, don't close */
46: BOOL debug;
47: BOOL nonblocking;
48: BOOL is_connected;
49: BOOL network_byte_order;
50: int last_error;
51: int type;
52:
53: } private_t;
54:
55: static const char* getprivate_failure = "line %d %s JS_GetPrivate failed";
56:
57: static void dbprintf(BOOL error, private_t* p, char* fmt, ...)
58: {
59: va_list argptr;
60: char sbuf[1024];
61:
62: if(p==NULL || (!p->debug /*&& !error */))
63: return;
64:
65: va_start(argptr,fmt);
66: vsnprintf(sbuf,sizeof(sbuf),fmt,argptr);
67: sbuf[sizeof(sbuf)-1]=0;
68: va_end(argptr);
69:
70: lprintf(LOG_DEBUG,"%04d Socket %s%s",p->sock,error ? "ERROR: ":"",sbuf);
71: }
72:
73: /* Socket Destructor */
74:
75: static void js_finalize_socket(JSContext *cx, JSObject *obj)
76: {
77: private_t* p;
78:
79: if((p=(private_t*)JS_GetPrivate(cx,obj))==NULL)
80: return;
81:
82: if(p->external==FALSE && p->sock!=INVALID_SOCKET) {
83: close_socket(p->sock);
84: dbprintf(FALSE, p, "closed/deleted");
85: }
86:
87: free(p);
88:
89: JS_SetPrivate(cx, obj, NULL);
90: }
91:
92:
93: /* Socket Object Methods */
94:
95: static JSBool
96: js_close(JSContext *cx, JSObject *obj, uintN argc, jsval *argv, jsval *rval)
97: {
98: private_t* p;
99:
100: if((p=(private_t*)JS_GetPrivate(cx,obj))==NULL) {
101: JS_ReportError(cx,getprivate_failure,WHERE);
102: return(JS_FALSE);
103: }
104:
105: if(p->sock==INVALID_SOCKET)
106: return(JS_TRUE);
107:
108: close_socket(p->sock);
109:
110: p->last_error = ERROR_VALUE;
111:
112: dbprintf(FALSE, p, "closed");
113:
114: p->sock = INVALID_SOCKET;
115: p->is_connected = FALSE;
116:
117: return(JS_TRUE);
118: }
119:
120: static ushort js_port(JSContext* cx, jsval val, int type)
121: {
122: char* cp;
123: JSString* str;
124: int32 i=0;
125: struct servent* serv;
126:
127: if(JSVAL_IS_NUMBER(val)) {
128: JS_ValueToInt32(cx,val,&i);
129: return((ushort)i);
130: }
131: if(JSVAL_IS_STRING(val)) {
132: str = JS_ValueToString(cx,val);
133: cp = JS_GetStringBytes(str);
134: if(isdigit(*cp))
135: return((ushort)strtol(cp,NULL,0));
136: serv = getservbyname(cp,type==SOCK_STREAM ? "tcp":"udp");
137: if(serv!=NULL)
138: return(htons(serv->s_port));
139: }
140: return(0);
141: }
142:
143: SOCKET DLLCALL js_socket(JSContext *cx, jsval val)
144: {
145: void* vp;
146: JSClass* cl;
147: SOCKET sock=INVALID_SOCKET;
148:
149: if(JSVAL_IS_OBJECT(val) && (cl=JS_GetClass(cx,JSVAL_TO_OBJECT(val)))!=NULL) {
150: if(cl->flags&JSCLASS_HAS_PRIVATE)
151: if((vp=JS_GetPrivate(cx,JSVAL_TO_OBJECT(val)))!=NULL)
152: sock=*(SOCKET*)vp;
153: } else if(val!=JSVAL_VOID)
154: JS_ValueToInt32(cx,val,(int32*)&sock);
155:
156: return(sock);
157: }
158:
159: void DLLCALL js_timeval(JSContext* cx, jsval val, struct timeval* tv)
160: {
161: jsdouble jsd;
162:
163: if(JSVAL_IS_INT(val))
164: tv->tv_sec = JSVAL_TO_INT(val);
165: else if(JSVAL_IS_DOUBLE(val)) {
166: JS_ValueToNumber(cx,val,&jsd);
167: tv->tv_sec = (int)jsd;
168: tv->tv_usec = (int)(jsd*1000000.0)%1000000;
169: }
170: }
171:
172: static JSBool
173: js_bind(JSContext *cx, JSObject *obj, uintN argc, jsval *argv, jsval *rval)
174: {
175: ulong ip=0;
176: SOCKADDR_IN addr;
177: private_t* p;
178: ushort port=0;
179:
180: if((p=(private_t*)JS_GetPrivate(cx,obj))==NULL) {
181: JS_ReportError(cx,getprivate_failure,WHERE);
182: return(JS_FALSE);
183: }
184:
185: memset(&addr,0,sizeof(addr));
186: addr.sin_family = AF_INET;
187:
188: if(argc)
189: port = js_port(cx,argv[0],p->type);
190: addr.sin_port = htons(port);
191: if(argc>1
192: && (ip=inet_addr(JS_GetStringBytes(JS_ValueToString(cx,argv[1]))))!=INADDR_NONE)
193: addr.sin_addr.s_addr = ip;
194:
195: if(bind(p->sock, (struct sockaddr *) &addr, sizeof(addr))!=0) {
196: p->last_error=ERROR_VALUE;
197: dbprintf(TRUE, p, "bind failed with error %d",ERROR_VALUE);
198: *rval = JSVAL_FALSE;
199: return(JS_TRUE);
200: }
201:
202: dbprintf(FALSE, p, "bound to port %u",port);
203: *rval = JSVAL_TRUE;
204: return(JS_TRUE);
205: }
206:
207: static JSBool
208: js_listen(JSContext *cx, JSObject *obj, uintN argc, jsval *argv, jsval *rval)
209: {
210: private_t* p;
211: int32 backlog=1;
212:
213: if((p=(private_t*)JS_GetPrivate(cx,obj))==NULL) {
214: JS_ReportError(cx,getprivate_failure,WHERE);
215: return(JS_FALSE);
216: }
217:
218: if(argc)
219: backlog = JS_ValueToInt32(cx,argv[0],&backlog);
220:
221: if(listen(p->sock, backlog)!=0) {
222: p->last_error=ERROR_VALUE;
223: dbprintf(TRUE, p, "listen failed with error %d",ERROR_VALUE);
224: *rval = JSVAL_FALSE;
225: return(JS_TRUE);
226: }
227:
228: dbprintf(FALSE, p, "listening, backlog=%d",backlog);
229: *rval = JSVAL_TRUE;
230: return(JS_TRUE);
231: }
232:
233: static JSBool
234: js_accept(JSContext *cx, JSObject *obj, uintN argc, jsval *argv, jsval *rval)
235: {
236: private_t* p;
237: private_t* new_p;
238: JSObject* sockobj;
239: SOCKET new_socket;
240:
241: if((p=(private_t*)JS_GetPrivate(cx,obj))==NULL) {
242: JS_ReportError(cx,getprivate_failure,WHERE);
243: return(JS_FALSE);
244: }
245:
246: if((new_socket=accept_socket(p->sock,NULL,NULL))==INVALID_SOCKET) {
247: p->last_error=ERROR_VALUE;
248: dbprintf(TRUE, p, "accept failed with error %d",ERROR_VALUE);
249: return(JS_TRUE);
250: }
251:
252: if((sockobj=js_CreateSocketObject(cx, obj, "new_socket", new_socket))==NULL) {
253: closesocket(new_socket);
254: JS_ReportError(cx,"Error creating new socket object");
255: return(JS_TRUE);
256: }
257: if((new_p=(private_t*)JS_GetPrivate(cx,sockobj))==NULL) {
258: JS_ReportError(cx,getprivate_failure,WHERE);
259: return(JS_FALSE);
260: }
261:
262: new_p->type=p->type;
263: new_p->debug=p->debug;
264: new_p->nonblocking=p->nonblocking;
265: new_p->external=FALSE; /* let destructor close socket */
266: new_p->is_connected=TRUE;
267:
268: dbprintf(FALSE, p, "accepted connection");
269: *rval = OBJECT_TO_JSVAL(sockobj);
270: return(JS_TRUE);
271: }
272:
273: static JSBool
274: js_connect(JSContext *cx, JSObject *obj, uintN argc, jsval *argv, jsval *rval)
275: {
276: int result;
277: ulong val;
278: ulong ip_addr;
279: ushort port;
280: JSString* str;
281: private_t* p;
282: SOCKADDR_IN addr;
283: fd_set socket_set;
284: struct timeval tv = {0, 0};
285:
286: if((p=(private_t*)JS_GetPrivate(cx,obj))==NULL) {
287: JS_ReportError(cx,getprivate_failure,WHERE);
288: return(JS_FALSE);
289: }
290:
291: str = JS_ValueToString(cx, argv[0]);
292: dbprintf(FALSE, p, "resolving hostname: %s", JS_GetStringBytes(str));
293: if((ip_addr=resolve_ip(JS_GetStringBytes(str)))==INADDR_NONE) {
294: p->last_error=ERROR_VALUE;
295: dbprintf(TRUE, p, "resolve_ip failed with error %d",ERROR_VALUE);
296: *rval = JSVAL_FALSE;
297: return(JS_TRUE);
298: }
299:
300: port = js_port(cx,argv[1],p->type);
301:
302: tv.tv_sec = 10; /* default time-out */
303:
304: if(argc>2) /* time-out value specified */
305: js_timeval(cx,argv[2],&tv);
306:
307: dbprintf(FALSE, p, "connecting to port %u at %s", port, JS_GetStringBytes(str));
308:
309: memset(&addr,0,sizeof(addr));
310: addr.sin_addr.s_addr = ip_addr;
311: addr.sin_family = AF_INET;
312: addr.sin_port = htons(port);
313:
314: /* always set to nonblocking here */
315: val=1;
316: ioctlsocket(p->sock,FIONBIO,&val);
317:
318: result=connect(p->sock, (struct sockaddr *)&addr, sizeof(addr));
319:
320: if(result==SOCKET_ERROR
321: && (ERROR_VALUE==EWOULDBLOCK || ERROR_VALUE==EINPROGRESS)) {
322: FD_ZERO(&socket_set);
323: FD_SET(p->sock,&socket_set);
324: if(select(p->sock+1,NULL,&socket_set,NULL,&tv)==1)
325: result=0; /* success */
326: }
327:
328: /* Restore original setting here */
329: ioctlsocket(p->sock,FIONBIO,(ulong*)&(p->nonblocking));
330:
331: if(result!=0) {
332: p->last_error=ERROR_VALUE;
333: dbprintf(TRUE, p, "connect failed with error %d",ERROR_VALUE);
334: *rval = JSVAL_FALSE;
335: return(JS_TRUE);
336: }
337:
338: p->is_connected = TRUE;
339: *rval = JSVAL_TRUE;
340: dbprintf(FALSE, p, "connected to port %u at %s", port, JS_GetStringBytes(str));
341:
342: return(JS_TRUE);
343: }
344:
345: static JSBool
346: js_send(JSContext *cx, JSObject *obj, uintN argc, jsval *argv, jsval *rval)
347: {
348: char* cp;
349: int len;
350: JSString* str;
351: private_t* p;
352:
353: if((p=(private_t*)JS_GetPrivate(cx,obj))==NULL) {
354: JS_ReportError(cx,getprivate_failure,WHERE);
355: return(JS_FALSE);
356: }
357:
358: *rval = JSVAL_FALSE;
359:
360: str = JS_ValueToString(cx, argv[0]);
361: cp = JS_GetStringBytes(str);
362: len = JS_GetStringLength(str);
363:
364: if(sendsocket(p->sock,cp,len)==len) {
365: dbprintf(FALSE, p, "sent %u bytes",len);
366: *rval = JSVAL_TRUE;
367: } else {
368: p->last_error=ERROR_VALUE;
369: dbprintf(TRUE, p, "send of %u bytes failed",len);
370: }
371:
372: return(JS_TRUE);
373: }
374:
375: static JSBool
376: js_sendto(JSContext *cx, JSObject *obj, uintN argc, jsval *argv, jsval *rval)
377: {
378: char* cp;
379: int len;
380: ulong ip_addr;
381: ushort port;
382: JSString* data_str;
383: JSString* ip_str;
384: private_t* p;
385: SOCKADDR_IN addr;
386:
387: if((p=(private_t*)JS_GetPrivate(cx,obj))==NULL) {
388: JS_ReportError(cx,getprivate_failure,WHERE);
389: return(JS_FALSE);
390: }
391:
392: *rval = JSVAL_FALSE;
393:
394: /* data */
395: data_str = JS_ValueToString(cx, argv[0]);
396: cp = JS_GetStringBytes(data_str);
397: len = JS_GetStringLength(data_str);
398:
399: /* address */
400: ip_str = JS_ValueToString(cx, argv[1]);
401: dbprintf(FALSE, p, "resolving hostname: %s", JS_GetStringBytes(ip_str));
402: if((ip_addr=resolve_ip(JS_GetStringBytes(ip_str)))==INADDR_NONE) {
403: p->last_error=ERROR_VALUE;
404: dbprintf(TRUE, p, "resolve_ip failed with error %d",ERROR_VALUE);
405: *rval = JSVAL_FALSE;
406: return(JS_TRUE);
407: }
408:
409: /* port */
410: port = js_port(cx,argv[2],p->type);
411:
412: dbprintf(FALSE, p, "sending %d bytes to port %u at %s"
413: ,len, port, JS_GetStringBytes(ip_str));
414:
415: memset(&addr,0,sizeof(addr));
416: addr.sin_addr.s_addr = ip_addr;
417: addr.sin_family = AF_INET;
418: addr.sin_port = htons(port);
419:
420: if(sendto(p->sock,cp,len,0 /* flags */,(SOCKADDR*)&addr,sizeof(addr))==len) {
421: dbprintf(FALSE, p, "sent %u bytes",len);
422: *rval = JSVAL_TRUE;
423: } else {
424: p->last_error=ERROR_VALUE;
425: dbprintf(TRUE, p, "send of %u bytes failed",len);
426: }
427:
428: return(JS_TRUE);
429: }
430:
431:
432: static JSBool
433: js_sendfile(JSContext *cx, JSObject *obj, uintN argc, jsval *argv, jsval *rval)
434: {
435: char* fname;
436: long len;
437: int file;
438: JSString* str;
439: private_t* p;
440:
441: if((p=(private_t*)JS_GetPrivate(cx,obj))==NULL) {
442: JS_ReportError(cx,getprivate_failure,WHERE);
443: return(JS_FALSE);
444: }
445:
446: *rval = JSVAL_FALSE;
447:
448: if((str = JS_ValueToString(cx, argv[0]))==NULL
449: || (fname=JS_GetStringBytes(str))==NULL) {
450: JS_ReportError(cx,"Failure reading filename");
451: return(JS_FALSE);
452: }
453:
454: if((file=nopen(fname,O_RDONLY|O_BINARY))==-1)
455: return(JS_TRUE);
456:
457: #if 0
458: len=filelength(file);
459: /* TODO: Probobly too big for alloca()... also, this is insane. */
460: if((buf=malloc(len))==NULL) {
461: close(file);
462: return(JS_TRUE);
463: }
464: if(read(file,buf,len)!=len) {
465: free(buf);
466: close(file);
467: return(JS_TRUE);
468: }
469: close(file);
470:
471: if(sendsocket(p->sock,buf,len)==len) {
472: dbprintf(FALSE, p, "sent %u bytes",len);
473: *rval = JSVAL_TRUE;
474: } else {
475: p->last_error=ERROR_VALUE;
476: dbprintf(TRUE, p, "send of %u bytes failed",len);
477: }
478: free(buf);
479: #else
480: len = sendfilesocket(p->sock, file, NULL, 0);
481: if(len > 0) {
482: dbprintf(FALSE, p, "sent %u bytes",len);
483: *rval = JSVAL_TRUE;
484: } else {
485: p->last_error=ERROR_VALUE;
486: dbprintf(TRUE, p, "send of %s failed",fname);
487: }
488: #endif
489:
490: return(JS_TRUE);
491: }
492:
493: static JSBool
494: js_sendbin(JSContext *cx, JSObject *obj, uintN argc, jsval *argv, jsval *rval)
495: {
496: BYTE b;
497: WORD w;
498: DWORD l;
499: int32 val=0;
500: size_t wr=0;
501: size_t size=sizeof(DWORD);
502: private_t* p;
503:
504: *rval = JSVAL_FALSE;
505:
506: if((p=(private_t*)JS_GetPrivate(cx,obj))==NULL) {
507: JS_ReportError(cx,getprivate_failure,WHERE);
508: return(JS_FALSE);
509: }
510:
511: JS_ValueToInt32(cx,argv[0],&val);
512: if(argc>1)
513: JS_ValueToInt32(cx,argv[1],(int32*)&size);
514:
515: switch(size) {
516: case sizeof(BYTE):
517: b = (BYTE)val;
518: wr=sendsocket(p->sock,&b,size);
519: break;
520: case sizeof(WORD):
521: w = (WORD)val;
522: if(p->network_byte_order)
523: w=htons(w);
524: wr=sendsocket(p->sock,(BYTE*)&w,size);
525: break;
526: case sizeof(DWORD):
527: l = val;
528: if(p->network_byte_order)
529: l=htonl(l);
530: wr=sendsocket(p->sock,(BYTE*)&l,size);
531: break;
532: default:
533: /* unknown size */
534: dbprintf(TRUE, p, "unsupported binary write size: %d",size);
535: break;
536: }
537: if(wr==size) {
538: dbprintf(FALSE, p, "sent %u bytes (binary)",size);
539: *rval = JSVAL_TRUE;
540: } else {
541: p->last_error=ERROR_VALUE;
542: dbprintf(TRUE, p, "send of %u bytes (binary) failed",size);
543: }
544:
545: return(JS_TRUE);
546: }
547:
548:
549: static JSBool
550: js_recv(JSContext *cx, JSObject *obj, uintN argc, jsval *argv, jsval *rval)
551: {
552: char* buf;
553: int32 len=512;
554: JSString* str;
555:
556: private_t* p;
557:
558: if((p=(private_t*)JS_GetPrivate(cx,obj))==NULL) {
559: JS_ReportError(cx,getprivate_failure,WHERE);
560: return(JS_FALSE);
561: }
562:
563: if(argc)
564: JS_ValueToInt32(cx,argv[0],&len);
565:
566: if((buf=(char*)alloca(len+1))==NULL) {
567: JS_ReportError(cx,"Error allocating %u bytes",len+1);
568: return(JS_FALSE);
569: }
570:
571: len = recv(p->sock,buf,len,0);
572: if(len<0) {
573: p->last_error=ERROR_VALUE;
574: *rval = JSVAL_NULL;
575: return(JS_TRUE);
576: }
577: buf[len]=0;
578:
579: str = JS_NewStringCopyN(cx, buf, len);
580: if(str==NULL)
581: return(JS_FALSE);
582:
583: *rval = STRING_TO_JSVAL(str);
584: dbprintf(FALSE, p, "received %u bytes",len);
585:
586: return(JS_TRUE);
587: }
588:
589: static JSBool
590: js_recvfrom(JSContext *cx, JSObject *obj, uintN argc, jsval *argv, jsval *rval)
591: {
592: char* buf;
593: char ip_addr[64];
594: char port[32];
595: int rd=0;
596: int32 len=512;
597: uintN n;
598: BOOL binary=FALSE;
599: BYTE b;
600: WORD w;
601: DWORD l;
602: jsval data_val=JSVAL_NULL;
603: JSString* str;
604: JSObject* retobj;
605: SOCKADDR_IN addr;
606: socklen_t addrlen;
607:
608: private_t* p;
609:
610: if((p=(private_t*)JS_GetPrivate(cx,obj))==NULL) {
611: JS_ReportError(cx,getprivate_failure,WHERE);
612: return(JS_FALSE);
613: }
614:
615: *rval = JSVAL_NULL;
616:
617: for(n=0;n<argc;n++) {
618: if(JSVAL_IS_BOOLEAN(argv[n])) {
619: binary=JSVAL_TO_BOOLEAN(argv[n]);
620: if(binary)
621: len=sizeof(DWORD);
622: } else
623: JS_ValueToInt32(cx,argv[n],&len);
624: }
625:
626: addrlen=sizeof(addr);
627:
628: if(binary) { /* Binary/Integer Data */
629:
630: switch(len) {
631: case sizeof(BYTE):
632: if((rd=recvfrom(p->sock,&b,len,0,(SOCKADDR*)&addr,&addrlen))==len)
633: data_val = INT_TO_JSVAL(b);
634: break;
635: case sizeof(WORD):
636: if((rd=recvfrom(p->sock,(BYTE*)&w,len,0,(SOCKADDR*)&addr,&addrlen))==len) {
637: if(p->network_byte_order)
638: w=ntohs(w);
639: data_val = INT_TO_JSVAL(w);
640: }
641: break;
642: case sizeof(DWORD):
643: if((rd=recvfrom(p->sock,(BYTE*)&l,len,0,(SOCKADDR*)&addr,&addrlen))==len) {
644: if(p->network_byte_order)
645: l=ntohl(l);
646: JS_NewNumberValue(cx,l,&data_val);
647: }
648: break;
649: }
650:
651: if(rd!=len) {
652: p->last_error=ERROR_VALUE;
653: return(JS_TRUE);
654: }
655:
656: } else { /* String Data */
657:
658: if((buf=(char*)alloca(len+1))==NULL) {
659: JS_ReportError(cx,"Error allocating %u bytes",len+1);
660: return(JS_FALSE);
661: }
662:
663: len = recvfrom(p->sock,buf,len,0,(SOCKADDR*)&addr,&addrlen);
664: if(len<0) {
665: p->last_error=ERROR_VALUE;
666: return(JS_TRUE);
667: }
668: buf[len]=0;
669:
670: str = JS_NewStringCopyN(cx, buf, len);
671:
672: if(str==NULL)
673: return(JS_FALSE);
674:
675: data_val = STRING_TO_JSVAL(str);
676: }
677:
678:
679: if((retobj=JS_NewObject(cx,NULL,NULL,obj))==NULL) {
680: JS_ReportError(cx,"JS_NewObject failed");
681: return(JS_FALSE);
682: }
683:
684: JS_DefineProperty(cx, retobj, "data"
685: ,data_val
686: ,NULL,NULL,JSPROP_ENUMERATE);
687:
688: sprintf(port,"%u",ntohs(addr.sin_port));
689: if((str=JS_NewStringCopyZ(cx,port))==NULL)
690: return(JS_FALSE);
691: JS_DefineProperty(cx, retobj, "port"
692: ,STRING_TO_JSVAL(str)
693: ,NULL,NULL,JSPROP_ENUMERATE);
694:
695: SAFECOPY(ip_addr,inet_ntoa(addr.sin_addr));
696: if((str=JS_NewStringCopyZ(cx,ip_addr))==NULL)
697: return(JS_FALSE);
698: JS_DefineProperty(cx, retobj, "ip_address"
699: ,STRING_TO_JSVAL(str)
700: ,NULL,NULL,JSPROP_ENUMERATE);
701:
702: *rval = OBJECT_TO_JSVAL(retobj);
703:
704: dbprintf(FALSE, p, "received %u bytes from %s:%s",len,ip_addr,port);
705:
706: return(JS_TRUE);
707: }
708:
709:
710: static JSBool
711: js_peek(JSContext *cx, JSObject *obj, uintN argc, jsval *argv, jsval *rval)
712: {
713: char* buf;
714: int32 len=512;
715: JSString* str;
716:
717: private_t* p;
718:
719: if((p=(private_t*)JS_GetPrivate(cx,obj))==NULL) {
720: JS_ReportError(cx,getprivate_failure,WHERE);
721: return(JS_FALSE);
722: }
723:
724: if(argc)
725: JS_ValueToInt32(cx,argv[0],&len);
726:
727: if((buf=(char*)alloca(len+1))==NULL) {
728: JS_ReportError(cx,"Error allocating %u bytes",len+1);
729: return(JS_FALSE);
730: }
731: len = recv(p->sock,buf,len,MSG_PEEK);
732: if(len<0) {
733: p->last_error=ERROR_VALUE;
734: *rval = JSVAL_NULL;
735: return(JS_TRUE);
736: }
737: buf[len]=0;
738:
739: str = JS_NewStringCopyN(cx, buf, len);
740: if(str==NULL)
741: return(JS_FALSE);
742:
743: *rval = STRING_TO_JSVAL(str);
744: dbprintf(FALSE, p, "received %u bytes, lasterror=%d"
745: ,len,ERROR_VALUE);
746:
747: return(JS_TRUE);
748: }
749:
750: static JSBool
751: js_recvline(JSContext *cx, JSObject *obj, uintN argc, jsval *argv, jsval *rval)
752: {
753: char ch;
754: char* buf;
755: int i;
756: int32 len=512;
757: BOOL rd;
758: time_t start;
759: int32 timeout=30; /* seconds */
760: JSString* str;
761: private_t* p;
762:
763: if((p=(private_t*)JS_GetPrivate(cx,obj))==NULL) {
764: JS_ReportError(cx,getprivate_failure,WHERE);
765: return(JS_FALSE);
766: }
767:
768: if(argc)
769: JS_ValueToInt32(cx,argv[0],&len);
770:
771: if((buf=(char*)alloca(len+1))==NULL) {
772: JS_ReportError(cx,"Error allocating %u bytes",len+1);
773: return(JS_FALSE);
774: }
775:
776: if(argc>1)
777: JS_ValueToInt32(cx,argv[1],(int32*)&timeout);
778:
779: start=time(NULL);
780: for(i=0;i<len;) {
781:
782: if(!socket_check(p->sock,&rd,NULL,1000)) {
783: p->last_error=ERROR_VALUE;
784: break; /* disconnected */
785: }
786:
787: if(!rd) {
788: if(time(NULL)-start>timeout) {
789: dbprintf(FALSE, p, "recvline timeout (received: %d)",i);
790: *rval = JSVAL_NULL;
791: return(JS_TRUE); /* time-out */
792: }
793: continue; /* no data */
794: }
795:
796: if(recv(p->sock, &ch, 1, 0)!=1) {
797: p->last_error=ERROR_VALUE;
798: break;
799: }
800:
801: if(ch=='\n' /* && i>=1 */) /* Mar-9-2003: terminate on sole LF */
802: break;
803:
804: buf[i++]=ch;
805: }
806: if(i>0 && buf[i-1]=='\r')
807: buf[i-1]=0;
808: else
809: buf[i]=0;
810:
811: str = JS_NewStringCopyZ(cx, buf);
812: if(str==NULL)
813: return(JS_FALSE);
814:
815: *rval = STRING_TO_JSVAL(str);
816: dbprintf(FALSE, p, "received %u bytes (recvline) lasterror=%d"
817: ,i,ERROR_VALUE);
818:
819: return(JS_TRUE);
820: }
821:
822: static JSBool
823: js_recvbin(JSContext *cx, JSObject *obj, uintN argc, jsval *argv, jsval *rval)
824: {
825: BYTE b;
826: WORD w;
827: DWORD l;
828: int size=sizeof(DWORD);
829: int rd=0;
830: private_t* p;
831:
832: *rval = INT_TO_JSVAL(-1);
833:
834: if((p=(private_t*)JS_GetPrivate(cx,obj))==NULL) {
835: JS_ReportError(cx,getprivate_failure,WHERE);
836: return(JS_FALSE);
837: }
838:
839: if(argc)
840: JS_ValueToInt32(cx,argv[0],(int32*)&size);
841:
842: switch(size) {
843: case sizeof(BYTE):
844: if((rd=recv(p->sock,&b,size,0))==size)
845: *rval = INT_TO_JSVAL(b);
846: break;
847: case sizeof(WORD):
848: if((rd=recv(p->sock,(BYTE*)&w,size,0))==size) {
849: if(p->network_byte_order)
850: w=ntohs(w);
851: *rval = INT_TO_JSVAL(w);
852: }
853: break;
854: case sizeof(DWORD):
855: if((rd=recv(p->sock,(BYTE*)&l,size,0))==size) {
856: if(p->network_byte_order)
857: l=ntohl(l);
858: JS_NewNumberValue(cx,l,rval);
859: }
860: break;
861: }
862:
863: if(rd!=size)
864: p->last_error=ERROR_VALUE;
865:
866: return(JS_TRUE);
867: }
868:
869:
870: static JSBool
871: js_getsockopt(JSContext *cx, JSObject *obj, uintN argc, jsval *argv, jsval *rval)
872: {
873: int opt;
874: int level;
875: int val;
876: private_t* p;
877: LINGER linger;
878: void* vp=&val;
879: socklen_t len=sizeof(val);
880:
881: *rval = INT_TO_JSVAL(-1);
882:
883: if((p=(private_t*)JS_GetPrivate(cx,obj))==NULL) {
884: JS_ReportError(cx,getprivate_failure,WHERE);
885: return(JS_FALSE);
886: }
887:
888: if((opt = getSocketOptionByName(JS_GetStringBytes(JS_ValueToString(cx,argv[0])),&level)) == -1)
889: return(JS_TRUE);
890:
891: if(opt == SO_LINGER) {
892: vp=&linger;
893: len=sizeof(linger);
894: }
895: if(getsockopt(p->sock, level, opt, vp, &len)==0) {
896: if(opt == SO_LINGER) {
897: if(linger.l_onoff==TRUE)
898: val = linger.l_linger;
899: else
900: val = 0;
901: }
902: JS_NewNumberValue(cx,val,rval);
903: } else {
904: p->last_error=ERROR_VALUE;
905: dbprintf(TRUE, p, "error %d getting option %d"
906: ,ERROR_VALUE,opt);
907: }
908:
909: return(JS_TRUE);
910: }
911:
912:
913: static JSBool
914: js_setsockopt(JSContext *cx, JSObject *obj, uintN argc, jsval *argv, jsval *rval)
915: {
916: int opt;
917: int level;
918: int32 val=1;
919: private_t* p;
920: LINGER linger;
921: void* vp=&val;
922: socklen_t len=sizeof(val);
923:
924:
925: if((p=(private_t*)JS_GetPrivate(cx,obj))==NULL) {
926: JS_ReportError(cx,getprivate_failure,WHERE);
927: return(JS_FALSE);
928: }
929:
930: opt = getSocketOptionByName(JS_GetStringBytes(JS_ValueToString(cx,argv[0])),&level);
931: JS_ValueToInt32(cx,argv[1],&val);
932:
933: if(opt == SO_LINGER) {
934: if(val) {
935: linger.l_onoff = TRUE;
936: linger.l_linger = (ushort)val;
937: } else {
938: ZERO_VAR(linger);
939: }
940: vp=&linger;
941: len=sizeof(linger);
942: }
943:
944: *rval = BOOLEAN_TO_JSVAL(
945: setsockopt(p->sock, level, opt, vp, len)==0);
946: p->last_error=ERROR_VALUE;
947:
948: return(JS_TRUE);
949: }
950:
951: static JSBool
952: js_ioctlsocket(JSContext *cx, JSObject *obj, uintN argc, jsval *argv, jsval *rval)
953: {
954: int32 cmd;
955: int32 arg=0;
956: private_t* p;
957:
958: if((p=(private_t*)JS_GetPrivate(cx,obj))==NULL) {
959: JS_ReportError(cx,getprivate_failure,WHERE);
960: return(JS_FALSE);
961: }
962:
963: JS_ValueToInt32(cx,argv[0],&cmd);
964: if(argc>1)
965: JS_ValueToInt32(cx,argv[1],&arg);
966:
967: if(ioctlsocket(p->sock,cmd,(ulong*)&arg)==0)
968: JS_NewNumberValue(cx,arg,rval);
969: else
970: *rval = INT_TO_JSVAL(-1);
971:
972: p->last_error=ERROR_VALUE;
973:
974: return(JS_TRUE);
975: }
976:
977: static JSBool
978: js_poll(JSContext *cx, JSObject *obj, uintN argc, jsval *argv, jsval *rval)
979: {
980: private_t* p;
981: BOOL poll_for_write=FALSE;
982: fd_set socket_set;
983: fd_set* rd_set=NULL;
984: fd_set* wr_set=NULL;
985: uintN argn;
986: int result;
987: struct timeval tv = {0, 0};
988:
989: if((p=(private_t*)JS_GetPrivate(cx,obj))==NULL) {
990: JS_ReportError(cx,getprivate_failure,WHERE);
991: return(JS_FALSE);
992: }
993:
994: if(p->sock==INVALID_SOCKET) {
995: dbprintf(TRUE, p, "INVALID SOCKET in call to poll");
996: *rval = INT_TO_JSVAL(-1);
997: return(JS_TRUE);
998: }
999:
1000: for(argn=0;argn<argc;argn++) {
1001: if(JSVAL_IS_BOOLEAN(argv[argn]))
1002: poll_for_write=JSVAL_TO_BOOLEAN(argv[argn]);
1003: else if(JSVAL_IS_NUMBER(argv[argn]))
1004: js_timeval(cx,argv[argn],&tv);
1005: }
1006:
1007: FD_ZERO(&socket_set);
1008: FD_SET(p->sock,&socket_set);
1009: if(poll_for_write)
1010: wr_set=&socket_set;
1011: else
1012: rd_set=&socket_set;
1013:
1014: result = select(p->sock+1,rd_set,wr_set,NULL,&tv);
1015:
1016: p->last_error=ERROR_VALUE;
1017:
1018: dbprintf(FALSE, p, "poll: select returned %d (errno %d)"
1019: ,result,p->last_error);
1020:
1021: *rval = INT_TO_JSVAL(result);
1022:
1023: return(JS_TRUE);
1024: }
1025:
1026:
1027: /* Socket Object Properites */
1028: enum {
1029: SOCK_PROP_LAST_ERROR
1030: ,SOCK_PROP_IS_CONNECTED
1031: ,SOCK_PROP_IS_WRITEABLE
1032: ,SOCK_PROP_DATA_WAITING
1033: ,SOCK_PROP_NREAD
1034: ,SOCK_PROP_DEBUG
1035: ,SOCK_PROP_DESCRIPTOR
1036: ,SOCK_PROP_NONBLOCKING
1037: ,SOCK_PROP_LOCAL_IP
1038: ,SOCK_PROP_LOCAL_PORT
1039: ,SOCK_PROP_REMOTE_IP
1040: ,SOCK_PROP_REMOTE_PORT
1041: ,SOCK_PROP_TYPE
1042: ,SOCK_PROP_NETWORK_ORDER
1043:
1044: };
1045:
1046: #ifdef BUILD_JSDOCS
1047: static char* socket_prop_desc[] = {
1048: "error status for the last socket operation that failed - <small>READ ONLY</small>"
1049: ,"<i>true</i> if socket is in a connected state - <small>READ ONLY</small>"
1050: ,"<i>true</i> if socket can accept written data - <small>READ ONLY</small>"
1051: ,"<i>true</i> if data is waiting to be read from socket - <small>READ ONLY</small>"
1052: ,"number of bytes waiting to be read - <small>READ ONLY</small>"
1053: ,"enable debug logging"
1054: ,"socket descriptor (advanced uses only)"
1055: ,"use non-blocking operation (default is <i>false</i>)"
1056: ,"local IP address (string in dotted-decimal format)"
1057: ,"local TCP or UDP port number"
1058: ,"remote IP address (string in dotted-decimal format)"
1059: ,"remote TCP or UDP port number"
1060: ,"socket type, <tt>SOCK_STREAM</tt> (TCP) or <tt>SOCK_DGRAM</tt> (UDP)"
1061: ,"<i>true</i> if binary data is to be sent in Network Byte Order (big end first), default is <i>true</i>"
1062: /* statically-defined properties: */
1063: ,"array of socket option names supported by the current platform"
1064: ,NULL
1065: };
1066: #endif
1067:
1068: static JSBool js_socket_set(JSContext *cx, JSObject *obj, jsval id, jsval *vp)
1069: {
1070: jsint tiny;
1071: private_t* p;
1072:
1073: if((p=(private_t*)JS_GetPrivate(cx,obj))==NULL) {
1074: JS_ReportError(cx,getprivate_failure,WHERE);
1075: return(JS_FALSE);
1076: }
1077:
1078: tiny = JSVAL_TO_INT(id);
1079:
1080: dbprintf(FALSE, p, "setting property %d",tiny);
1081:
1082: switch(tiny) {
1083: case SOCK_PROP_DEBUG:
1084: JS_ValueToBoolean(cx,*vp,&(p->debug));
1085: break;
1086: case SOCK_PROP_DESCRIPTOR:
1087: JS_ValueToInt32(cx,*vp,(int32*)&(p->sock));
1088: break;
1089: case SOCK_PROP_LAST_ERROR:
1090: JS_ValueToInt32(cx,*vp,(int32*)&(p->last_error));
1091: break;
1092: case SOCK_PROP_NONBLOCKING:
1093: JS_ValueToBoolean(cx,*vp,&(p->nonblocking));
1094: ioctlsocket(p->sock,FIONBIO,(ulong*)&(p->nonblocking));
1095: break;
1096: case SOCK_PROP_NETWORK_ORDER:
1097: JS_ValueToBoolean(cx,*vp,&(p->network_byte_order));
1098: break;
1099: }
1100:
1101: return(JS_TRUE);
1102: }
1103:
1104: static JSBool js_socket_get(JSContext *cx, JSObject *obj, jsval id, jsval *vp)
1105: {
1106: jsint tiny;
1107: ulong cnt;
1108: BOOL rd;
1109: BOOL wr;
1110: private_t* p;
1111: socklen_t addr_len;
1112: SOCKADDR_IN addr;
1113: JSString* js_str;
1114:
1115: if((p=(private_t*)JS_GetPrivate(cx,obj))==NULL) {
1116: JS_ReportError(cx,getprivate_failure,WHERE);
1117: return(JS_FALSE);
1118: }
1119:
1120: tiny = JSVAL_TO_INT(id);
1121:
1122: #if 0 /* just too much */
1123: dbprintf(FALSE, p, "getting property %d",tiny);
1124: #endif
1125:
1126: switch(tiny) {
1127: case SOCK_PROP_LAST_ERROR:
1128: *vp = INT_TO_JSVAL(p->last_error);
1129: break;
1130: case SOCK_PROP_IS_CONNECTED:
1131: if(!p->is_connected && !p->external)
1132: *vp = JSVAL_FALSE;
1133: else
1134: *vp = BOOLEAN_TO_JSVAL(socket_check(p->sock,NULL,NULL,0));
1135: break;
1136: case SOCK_PROP_IS_WRITEABLE:
1137: socket_check(p->sock,NULL,&wr,0);
1138: *vp = BOOLEAN_TO_JSVAL(wr);
1139: break;
1140: case SOCK_PROP_DATA_WAITING:
1141: socket_check(p->sock,&rd,NULL,0);
1142: *vp = BOOLEAN_TO_JSVAL(rd);
1143: break;
1144: case SOCK_PROP_NREAD:
1145: cnt=0;
1146: if(ioctlsocket(p->sock, FIONREAD, &cnt)==0)
1147: JS_NewNumberValue(cx,cnt,vp);
1148: else
1149: *vp = JSVAL_ZERO;
1150: break;
1151: case SOCK_PROP_DEBUG:
1152: *vp = INT_TO_JSVAL(p->debug);
1153: break;
1154: case SOCK_PROP_DESCRIPTOR:
1155: *vp = INT_TO_JSVAL(p->sock);
1156: break;
1157: case SOCK_PROP_NONBLOCKING:
1158: *vp = BOOLEAN_TO_JSVAL(p->nonblocking);
1159: break;
1160: case SOCK_PROP_LOCAL_IP:
1161: addr_len = sizeof(addr);
1162: if(getsockname(p->sock, (struct sockaddr *)&addr,&addr_len)!=0) {
1163: p->last_error=ERROR_VALUE;
1164: *vp = JSVAL_VOID;
1165: } else {
1166: if((js_str=JS_NewStringCopyZ(cx,inet_ntoa(addr.sin_addr)))==NULL)
1167: return(JS_FALSE);
1168: *vp = STRING_TO_JSVAL(js_str);
1169: }
1170: break;
1171: case SOCK_PROP_LOCAL_PORT:
1172: addr_len = sizeof(addr);
1173: if(getsockname(p->sock, (struct sockaddr *)&addr,&addr_len)!=0) {
1174: p->last_error=ERROR_VALUE;
1175: *vp = JSVAL_ZERO;
1176: } else
1177: *vp = INT_TO_JSVAL(ntohs(addr.sin_port));
1178: break;
1179: case SOCK_PROP_REMOTE_IP:
1180: addr_len = sizeof(addr);
1181: if(getpeername(p->sock, (struct sockaddr *)&addr,&addr_len)!=0) {
1182: p->last_error=ERROR_VALUE;
1183: *vp = JSVAL_VOID;
1184: } else {
1185: if((js_str=JS_NewStringCopyZ(cx,inet_ntoa(addr.sin_addr)))==NULL)
1186: return(JS_FALSE);
1187: *vp = STRING_TO_JSVAL(js_str);
1188: }
1189: break;
1190: case SOCK_PROP_REMOTE_PORT:
1191: addr_len = sizeof(addr);
1192: if(getpeername(p->sock, (struct sockaddr *)&addr,&addr_len)!=0) {
1193: p->last_error=ERROR_VALUE;
1194: *vp = JSVAL_ZERO;
1195: } else
1196: *vp = INT_TO_JSVAL(ntohs(addr.sin_port));
1197: break;
1198: case SOCK_PROP_TYPE:
1199: *vp = INT_TO_JSVAL(p->type);
1200: break;
1201: case SOCK_PROP_NETWORK_ORDER:
1202: *vp = BOOLEAN_TO_JSVAL(p->network_byte_order);
1203: break;
1204:
1205: }
1206:
1207: return(TRUE);
1208: }
1209:
1210: #define SOCK_PROP_FLAGS JSPROP_ENUMERATE|JSPROP_READONLY
1211:
1212: static jsSyncPropertySpec js_socket_properties[] = {
1213: /* name ,tinyid ,flags, ver */
1214:
1215: { "error" ,SOCK_PROP_LAST_ERROR ,SOCK_PROP_FLAGS, 311 },
1216: { "last_error" ,SOCK_PROP_LAST_ERROR ,JSPROP_READONLY, 310 }, /* alias */
1217: { "is_connected" ,SOCK_PROP_IS_CONNECTED ,SOCK_PROP_FLAGS, 310 },
1218: { "is_writeable" ,SOCK_PROP_IS_WRITEABLE ,SOCK_PROP_FLAGS, 311 },
1219: { "is_writable" ,SOCK_PROP_IS_WRITEABLE ,JSPROP_READONLY, 312 }, /* alias */
1220: { "data_waiting" ,SOCK_PROP_DATA_WAITING ,SOCK_PROP_FLAGS, 310 },
1221: { "nread" ,SOCK_PROP_NREAD ,SOCK_PROP_FLAGS, 310 },
1222: { "debug" ,SOCK_PROP_DEBUG ,JSPROP_ENUMERATE, 310 },
1223: { "descriptor" ,SOCK_PROP_DESCRIPTOR ,JSPROP_ENUMERATE, 310 },
1224: { "nonblocking" ,SOCK_PROP_NONBLOCKING ,JSPROP_ENUMERATE, 310 },
1225: { "local_ip_address" ,SOCK_PROP_LOCAL_IP ,SOCK_PROP_FLAGS, 310 },
1226: { "local_port" ,SOCK_PROP_LOCAL_PORT ,SOCK_PROP_FLAGS, 310 },
1227: { "remote_ip_address" ,SOCK_PROP_REMOTE_IP ,SOCK_PROP_FLAGS, 310 },
1228: { "remote_port" ,SOCK_PROP_REMOTE_PORT ,SOCK_PROP_FLAGS, 310 },
1229: { "type" ,SOCK_PROP_TYPE ,SOCK_PROP_FLAGS, 310 },
1230: { "network_byte_order",SOCK_PROP_NETWORK_ORDER,JSPROP_ENUMERATE, 311 },
1231: {0}
1232: };
1233:
1234: static JSClass js_socket_class = {
1235: "Socket" /* name */
1236: ,JSCLASS_HAS_PRIVATE /* flags */
1237: ,JS_PropertyStub /* addProperty */
1238: ,JS_PropertyStub /* delProperty */
1239: ,js_socket_get /* getProperty */
1240: ,js_socket_set /* setProperty */
1241: ,JS_EnumerateStub /* enumerate */
1242: ,JS_ResolveStub /* resolve */
1243: ,JS_ConvertStub /* convert */
1244: ,js_finalize_socket /* finalize */
1245: };
1246:
1247: static jsSyncMethodSpec js_socket_functions[] = {
1248: {"close", js_close, 0, JSTYPE_VOID, ""
1249: ,JSDOCSTR("close (shutdown) the socket immediately")
1250: ,310
1251: },
1252: {"bind", js_bind, 0, JSTYPE_BOOLEAN, JSDOCSTR("[port] [,ip_address]")
1253: ,JSDOCSTR("bind socket to a TCP or UDP <i>port</i> (number or service name), "
1254: "optionally specifying a network interface (via <i>ip_address</i>)")
1255: ,311
1256: },
1257: {"connect", js_connect, 2, JSTYPE_BOOLEAN, JSDOCSTR("host, port [,timeout=<tt>10.0</tt>]")
1258: ,JSDOCSTR("connect to a remote port (number or service name) on the specified host (IP address or host name)"
1259: ", default <i>timeout</i> value is <i>10.0</i> (seconds)")
1260: ,311
1261: },
1262: {"listen", js_listen, 0, JSTYPE_BOOLEAN, JSDOCSTR("")
1263: ,JSDOCSTR("place socket in a state to listen for incoming connections (use before an accept)")
1264: ,310
1265: },
1266: {"accept", js_accept, 0, JSTYPE_OBJECT, JSDOCSTR("")
1267: ,JSDOCSTR("accept an incoming connection, returns a new <i>Socket</i> object representing the new connection")
1268: ,310
1269: },
1270: {"write", js_send, 1, JSTYPE_ALIAS },
1271: {"send", js_send, 1, JSTYPE_BOOLEAN, JSDOCSTR("data")
1272: ,JSDOCSTR("send a string (AKA write)")
1273: ,310
1274: },
1275: {"sendto", js_sendto, 3, JSTYPE_BOOLEAN, JSDOCSTR("data, address, port")
1276: ,JSDOCSTR("send data to a specific host (IP address or host name) and port (number or service name), for UDP sockets")
1277: ,310
1278: },
1279: {"sendfile", js_sendfile, 1, JSTYPE_BOOLEAN, JSDOCSTR("path/filename")
1280: ,JSDOCSTR("send an entire file over the socket")
1281: ,310
1282: },
1283: {"writeBin", js_sendbin, 1, JSTYPE_ALIAS },
1284: {"sendBin", js_sendbin, 1, JSTYPE_BOOLEAN, JSDOCSTR("value [,bytes=<tt>4</tt>]")
1285: ,JSDOCSTR("send a binary integer over the socket, default number of bytes is 4 (32-bits)")
1286: ,311
1287: },
1288: {"read", js_recv, 1, JSTYPE_ALIAS },
1289: {"recv", js_recv, 1, JSTYPE_STRING, JSDOCSTR("[maxlen=<tt>512</tt>]")
1290: ,JSDOCSTR("receive a string, default maxlen is 512 characters (AKA read)")
1291: ,310
1292: },
1293: {"peek", js_peek, 0, JSTYPE_STRING, JSDOCSTR("[maxlen=<tt>512</tt>]")
1294: ,JSDOCSTR("receive a string, default maxlen is 512 characters, leaves string in receive buffer")
1295: ,310
1296: },
1297: {"readline", js_recvline, 0, JSTYPE_ALIAS },
1298: {"readln", js_recvline, 0, JSTYPE_ALIAS },
1299: {"recvline", js_recvline, 0, JSTYPE_STRING, JSDOCSTR("[maxlen=<tt>512</tt>] [,timeout=<tt>30.0</tt>]")
1300: ,JSDOCSTR("receive a line-feed terminated string, default maxlen is 512 characters, default timeout is 30 seconds (AKA readline and readln)")
1301: ,310
1302: },
1303: {"recvfrom", js_recvfrom, 0, JSTYPE_OBJECT, JSDOCSTR("[binary=<tt>false</tt>] [,maxlen=<tt>512</tt> or int_size=<tt>4</tt>]")
1304: ,JSDOCSTR("receive data (string or integer) from a socket (typically UDP)"
1305: "<p>returns object with <i>ip_address</i> and <i>port</i> of sender along with <i>data</i> properties"
1306: "<p><i>binary</i> defaults to <i>false</i>, <i>maxlen</i> defaults to 512 chars, <i>int_size</i> defaults to 4 bytes (32-bits)")
1307: ,311
1308: },
1309: {"readBin", js_recvbin, 0, JSTYPE_ALIAS },
1310: {"recvBin", js_recvbin, 0, JSTYPE_NUMBER, JSDOCSTR("[bytes=<tt>4</tt>]")
1311: ,JSDOCSTR("receive a binary integer from the socket, default number of bytes is 4 (32-bits)")
1312: ,311
1313: },
1314: {"getoption", js_getsockopt, 1, JSTYPE_NUMBER, JSDOCSTR("option")
1315: ,JSDOCSTR("get socket option value, option may be socket option name "
1316: "(see <tt>sockopts</tt> in <tt>sockdefs.js</tt>) or number")
1317: ,310
1318: },
1319: {"setoption", js_setsockopt, 2, JSTYPE_BOOLEAN, JSDOCSTR("option, value")
1320: ,JSDOCSTR("set socket option value, option may be socket option name "
1321: "(see <tt>sockopts</tt> in <tt>sockdefs.js</tt>) or number")
1322: ,310
1323: },
1324: {"ioctl", js_ioctlsocket, 1, JSTYPE_NUMBER, JSDOCSTR("command [,argument=<tt>0</tt>]")
1325: ,JSDOCSTR("send socket IOCTL (advanced)")
1326: ,310
1327: },
1328: {"poll", js_poll, 1, JSTYPE_NUMBER, JSDOCSTR("[timeout=<tt>0</tt>] [,write=<tt>false</tt>]")
1329: ,JSDOCSTR("poll socket for read or write ability (default is <i>read</i>), "
1330: "default timeout value is 0.0 seconds (immediate timeout)")
1331: ,310
1332: },
1333: {0}
1334: };
1335:
1336: static BOOL js_DefineSocketOptionsArray(JSContext *cx, JSObject *obj, int type)
1337: {
1338: size_t i;
1339: size_t count=0;
1340: jsval val;
1341: JSObject* array;
1342: socket_option_t* options;
1343:
1344: if((options=getSocketOptionList())==NULL)
1345: return(FALSE);
1346:
1347: if((array=JS_NewArrayObject(cx, 0, NULL))==NULL)
1348: return(FALSE);
1349:
1350: if(!JS_DefineProperty(cx, obj, "option_list", OBJECT_TO_JSVAL(array)
1351: , NULL, NULL, JSPROP_ENUMERATE))
1352: return(FALSE);
1353:
1354: for(i=0; options[i].name!=NULL; i++) {
1355: if(options[i].type && options[i].type!=type)
1356: continue;
1357: val=STRING_TO_JSVAL(JS_NewStringCopyZ(cx,options[i].name));
1358: JS_SetElement(cx, array, count++, &val);
1359: }
1360: return(TRUE);
1361: }
1362:
1363: /* Socket Constructor (creates socket descriptor) */
1364:
1365: static JSBool
1366: js_socket_constructor(JSContext *cx, JSObject *obj, uintN argc, jsval *argv, jsval *rval)
1367: {
1368: int32 type=SOCK_STREAM; /* default = TCP */
1369: uintN i;
1370: private_t* p;
1371: char* protocol=NULL;
1372:
1373: for(i=0;i<argc;i++) {
1374: if(JSVAL_IS_NUMBER(argv[i]))
1375: JS_ValueToInt32(cx,argv[i],&type);
1376: else if(protocol==NULL)
1377: protocol=JS_GetStringBytes(JS_ValueToString(cx,argv[i]));
1378: }
1379:
1380: if((p=(private_t*)malloc(sizeof(private_t)))==NULL) {
1381: JS_ReportError(cx,"malloc failed");
1382: return(JS_FALSE);
1383: }
1384: memset(p,0,sizeof(private_t));
1385:
1386: if((p->sock=open_socket(type,protocol))==INVALID_SOCKET) {
1387: JS_ReportError(cx,"open_socket failed with error %d",ERROR_VALUE);
1388: return(JS_FALSE);
1389: }
1390: p->type = type;
1391: p->network_byte_order = TRUE;
1392:
1393: if(!JS_SetPrivate(cx, obj, p)) {
1394: JS_ReportError(cx,"JS_SetPrivate failed");
1395: return(JS_FALSE);
1396: }
1397:
1398: if(!js_DefineSyncProperties(cx, obj, js_socket_properties)) {
1399: JS_ReportError(cx,"js_DefineSyncProperties failed");
1400: return(JS_FALSE);
1401: }
1402:
1403: if(!js_DefineSocketOptionsArray(cx, obj, type))
1404: return(JS_FALSE);
1405:
1406: if(!js_DefineSyncMethods(cx, obj, js_socket_functions, FALSE)) {
1407: JS_ReportError(cx,"js_DefineSyncMethods failed");
1408: return(JS_FALSE);
1409: }
1410:
1411: #ifdef BUILD_JSDOCS
1412: js_DescribeSyncObject(cx,obj,"Class used for TCP/IP socket communications",310);
1413: js_DescribeSyncConstructor(cx,obj,"To create a new Socket object: "
1414: "<tt>load('sockdefs.js'); var s = new Socket(<i>type</i>, <i>protocol</i>)</tt><br>"
1415: "where <i>type</i> = <tt>SOCK_STREAM</tt> for TCP (default) or <tt>SOCK_DGRAM</tt> for UDP<br>"
1416: "and <i>protocol</i> (optional) = the name of the protocol or service the socket is to be used for"
1417: );
1418: js_CreateArrayOfStrings(cx, obj, "_property_desc_list", socket_prop_desc, JSPROP_READONLY);
1419: #endif
1420:
1421: dbprintf(FALSE, p, "object constructed");
1422: return(JS_TRUE);
1423: }
1424:
1425: JSObject* DLLCALL js_CreateSocketClass(JSContext* cx, JSObject* parent)
1426: {
1427: JSObject* sockobj;
1428:
1429: sockobj = JS_InitClass(cx, parent, NULL
1430: ,&js_socket_class
1431: ,js_socket_constructor
1432: ,0 /* number of constructor args */
1433: ,NULL /* props, specified in constructor */
1434: ,NULL /* funcs, specified in constructor */
1435: ,NULL,NULL);
1436:
1437: return(sockobj);
1438: }
1439:
1440: JSObject* DLLCALL js_CreateSocketObject(JSContext* cx, JSObject* parent, char *name, SOCKET sock)
1441: {
1442: JSObject* obj;
1443: private_t* p;
1444: int type=SOCK_STREAM;
1445: socklen_t len;
1446:
1447: obj = JS_DefineObject(cx, parent, name, &js_socket_class, NULL
1448: ,JSPROP_ENUMERATE|JSPROP_READONLY);
1449:
1450: if(obj==NULL)
1451: return(NULL);
1452:
1453: if(!js_DefineSyncProperties(cx, obj, js_socket_properties))
1454: return(NULL);
1455:
1456: len = sizeof(type);
1457: getsockopt(sock,SOL_SOCKET,SO_TYPE,(void*)&type,&len);
1458:
1459: if(!js_DefineSocketOptionsArray(cx, obj, type))
1460: return(NULL);
1461:
1462: if((p=(private_t*)malloc(sizeof(private_t)))==NULL)
1463: return(NULL);
1464: memset(p,0,sizeof(private_t));
1465:
1466: p->sock = sock;
1467: p->external = TRUE;
1468: p->network_byte_order = TRUE;
1469:
1470: if(!JS_SetPrivate(cx, obj, p)) {
1471: dbprintf(TRUE, p, "JS_SetPrivate failed");
1472: return(NULL);
1473: }
1474:
1475: if (!js_DefineSyncMethods(cx, obj, js_socket_functions, FALSE))
1476: return(NULL);
1477:
1478: dbprintf(FALSE, p, "object created");
1479:
1480: return(obj);
1481: }
1482:
1483: #endif /* JAVSCRIPT */
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.