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