Commit | Line | Data |
2986a63f |
1 | |
2 | /* |
3 | * Copyright © 2001 Novell, Inc. All Rights Reserved. |
4 | * |
5 | * You may distribute under the terms of either the GNU General Public |
6 | * License or the Artistic License, as specified in the README file. |
7 | * |
8 | */ |
9 | |
10 | /* |
11 | * FILENAME : nw5.c |
12 | * DESCRIPTION : Definitions for the redefined functions for NetWare. |
13 | * Author : SGP, HYAK |
14 | * Date : January 2001. |
15 | * |
16 | */ |
17 | |
18 | |
19 | |
acfe0abc |
20 | #include <perl.h> // For dTHX, etc. |
2986a63f |
21 | #include "nwpipe.h" |
22 | |
23 | |
24 | // This was added since the compile failed saying "undefined P_WAIT" |
25 | // when USE_ITHREADS was commented in the makefile |
26 | #ifndef P_WAIT |
27 | #define P_WAIT 0 |
28 | #endif |
29 | |
30 | #ifndef P_NOWAIT |
31 | #define P_NOWAIT 1 |
32 | #endif |
33 | |
34 | // The array is used to store pointer to the memory allocated to the TempPipeFile structure everytime |
35 | // a call to the function, nw_Popen. If a simple variable is used, everytime the memory is allocated before |
36 | // the previously allocated memory is freed, the pointer will get overwritten and the previous memory allocations |
37 | // are lost! Only the most recent one will get freed when calls are made to nw_Pclose. |
38 | // By using the array and the iPopenCount to index the array, all memory are freed! |
39 | |
40 | // The size of the array indicates the limit on the no of times the nw_Popen function can be called (and |
41 | // memory allocted) from within a script through backtick operators! |
42 | // This is arbitrarily set to MAX_PIPE_RECURSION=256 which indicates there can be 256 nested backtick operators possible! |
43 | PTEMPPIPEFILE ptpf1[MAX_PIPE_RECURSION] = {'\0'}; |
44 | int iPopenCount = 0; |
45 | FILE* File1[MAX_PIPE_RECURSION] = {'\0'}; |
46 | |
47 | |
48 | /** |
49 | General: |
50 | |
51 | In this code, wherever there is a FILE *, the error condition is checked; and only if the FILE * is TRUE, |
52 | then the corresponding operation is done. Otherwise the error value is returned. |
53 | This is done because the file operations like "open" in the Perl code returns the FILE *, |
54 | returning a valid value if the file is found or NULL when the particular file is not found. |
55 | Now, if the return value is NULL, then an operation say "fgets", "fopen" etc. using this this NULL value |
56 | for FILE * will abend the server. If the check is made then an operation on a non existing file |
57 | does not abend the server. |
58 | **/ |
59 | |
60 | void |
61 | nw_abort(void) |
62 | { |
63 | abort(); // Terminate the NLM application abnormally. |
64 | return; |
65 | } |
66 | |
67 | int |
68 | nw_access(const char *path, int mode) |
69 | { |
70 | return access(path, mode); |
71 | } |
72 | |
73 | int |
74 | nw_chmod(const char *path, int mode) |
75 | { |
76 | return chmod(path, mode); |
77 | } |
78 | |
79 | void |
80 | nw_clearerr(FILE *pf) |
81 | { |
82 | if(pf) |
83 | clearerr(pf); |
84 | } |
85 | |
86 | int |
87 | nw_close(int fd) |
88 | { |
89 | return close(fd); |
90 | } |
91 | |
92 | nw_closedir(DIR *dirp) |
93 | { |
94 | return (closedir(dirp)); |
95 | } |
96 | |
97 | void |
98 | nw_setbuf(FILE *pf, char *buf) |
99 | { |
100 | if(pf) |
101 | setbuf(pf, buf); |
102 | } |
103 | |
104 | int |
105 | nw_setmode(FILE *fp, int mode) |
106 | { |
107 | int *dummy = 0; |
108 | return(fnFpSetMode(fp, mode, dummy)); |
109 | } |
110 | |
111 | int |
112 | nw_setvbuf(FILE *pf, char *buf, int type, size_t size) |
113 | { |
114 | if(pf) |
115 | return setvbuf(pf, buf, type, size); |
116 | else |
117 | return -1; |
118 | } |
119 | |
120 | |
121 | unsigned int |
122 | nw_sleep(unsigned int t) |
123 | { |
124 | delay(t*1000); // Put the thread to sleep for 't' seconds. Initially 't' is passed in milliseconds. |
125 | return 0; |
126 | } |
127 | |
128 | int |
129 | nw_spawnvp(int mode, char *cmdname, char **argv) |
130 | { |
131 | // There is no pass-around environment on NetWare so we throw that |
132 | // argument away for now. |
133 | |
134 | // The function "spawnvp" does not work in all situations. Loading |
135 | // edit.nlm seems to work, for example, but the name of the file |
136 | // to edit does not appear to get passed correctly. Another problem |
137 | // is that on Netware, P_WAIT does not really work reliably. It only |
138 | // works with NLMs built to use CLIB (according to Nile Thayne). |
139 | // NLMs such as EDIT that are written directly to the system have no |
140 | // way of running synchronously from another process. The whole |
141 | // architecture on NetWare seems pretty busted, so we just support it |
142 | // as best we can. |
143 | // |
144 | // The spawnvp function only launches NLMs, it will not execute a command; |
145 | // the NetWare "system" function is used for that purpose. Unfortunately, "system" |
146 | // always returns success whether the command is successful or not or even |
147 | // if the command was not found! To avoid ambiguity--you can have both an |
148 | // NLM named "perl" and a system command named "perl"--we need to |
149 | // force perl scripts to carry the word "load" when loading an NLM. This |
150 | // might be clearer anyway. |
151 | |
152 | int ret = 0; |
153 | int argc = 0; |
154 | |
155 | |
156 | if (stricmp(cmdname, LOAD_COMMAND) == 0) |
157 | { |
158 | if (argv[1] != NULL) |
159 | ret = spawnvp(mode, argv[1], &argv[1]); |
160 | } |
161 | else |
162 | { |
163 | int i=0; |
164 | while (argv[i] != '\0') |
165 | i++; |
166 | argc = i; |
167 | |
168 | fnSystemCommand(argv, argc); |
169 | } |
170 | |
171 | return ret; |
172 | } |
173 | |
174 | int |
175 | nw_execv(char *cmdname, char **argv) |
176 | { |
177 | return spawnvp(P_WAIT, cmdname, (char **)argv); |
178 | } |
179 | |
180 | |
181 | int |
182 | nw_execvp(char *cmdname, char **argv) |
183 | { |
184 | return nw_spawnvp(P_WAIT, cmdname, (char **)argv); |
185 | } |
186 | |
187 | int |
188 | nw_stat(const char *path, struct stat *sbuf) |
189 | { |
190 | return (stat(path, sbuf)); |
191 | } |
192 | |
193 | FILE * |
194 | nw_stderr(void) |
195 | { |
196 | return (stderr); |
197 | } |
198 | |
199 | FILE * |
200 | nw_stdin(void) |
201 | { |
202 | return (stdin); |
203 | } |
204 | |
205 | FILE * |
206 | nw_stdout() |
207 | { |
208 | return (stdout); |
209 | } |
210 | |
211 | long |
212 | nw_telldir(DIR *dirp) |
213 | { |
acfe0abc |
214 | dTHX; |
4d76e4b4 |
215 | Perl_croak(aTHX_ "The telldir() function is not implemented on NetWare\n"); |
2986a63f |
216 | return 0l; |
217 | } |
218 | |
219 | int |
220 | nw_times(struct tms *timebuf) |
221 | { |
222 | clock_t now = clock(); |
223 | |
224 | timebuf->tms_utime = now; |
225 | timebuf->tms_stime = 0; |
226 | timebuf->tms_cutime = 0; |
227 | timebuf->tms_cstime = 0; |
228 | |
229 | return 0; |
230 | } |
231 | |
232 | FILE* |
233 | nw_tmpfile(void) |
234 | { |
235 | return tmpfile(); |
236 | } |
237 | |
238 | int |
239 | nw_uname(struct utsname *name) |
240 | { |
241 | return(uname(name)); |
242 | } |
243 | |
244 | int |
245 | nw_ungetc(int c, FILE *pf) |
246 | { |
247 | if(pf) |
248 | return ungetc(c, pf); |
249 | else |
250 | return -1; |
251 | } |
252 | |
253 | int |
254 | nw_unlink(const char *filename) |
255 | { |
256 | return(unlink(filename)); |
257 | } |
258 | |
259 | int |
260 | nw_utime(const char *filename, struct utimbuf *times) |
261 | { |
262 | return(utime(filename, times)); |
263 | } |
264 | |
265 | int |
266 | nw_vfprintf(FILE *fp, const char *format, va_list args) |
267 | { |
268 | if(fp) |
269 | return (vfprintf(fp, format, args)); |
270 | else |
271 | return -1; |
272 | } |
273 | |
274 | int |
275 | nw_wait(int *status) |
276 | { |
277 | return 0; |
278 | } |
279 | |
280 | int |
281 | nw_waitpid(int pid, int *status, int flags) |
282 | { |
283 | return 0; |
284 | } |
285 | |
286 | int |
287 | nw_write(int fd, const void *buf, unsigned int cnt) |
288 | { |
289 | return write(fd, buf, cnt); |
290 | } |
291 | |
292 | char * |
293 | nw_crypt(const char *txt, const char *salt) |
294 | { |
acfe0abc |
295 | dTHX; |
2986a63f |
296 | |
297 | #ifdef HAVE_DES_FCRYPT |
298 | dTHR; |
299 | return des_fcrypt(txt, salt, w32_crypt_buffer); |
300 | #else |
4d76e4b4 |
301 | Perl_croak(aTHX_ "The crypt() function is not implemented on NetWare\n"); |
2986a63f |
302 | return Nullch; |
303 | #endif |
304 | } |
305 | |
306 | int |
307 | nw_dup(int fd) |
308 | { |
309 | return dup(fd); |
310 | } |
311 | |
312 | int |
313 | nw_dup2(int fd1,int fd2) |
314 | { |
315 | return dup2(fd1,fd2); |
316 | } |
317 | |
318 | void* |
319 | nw_dynaload(const char* filename) |
320 | { |
321 | return NULL; |
322 | } |
323 | |
324 | int |
325 | nw_fclose(FILE *pf) |
326 | { |
327 | if(pf) |
328 | return (fclose(pf)); |
329 | else |
330 | return -1; |
331 | } |
332 | |
333 | FILE * |
334 | nw_fdopen(int handle, const char *mode) |
335 | { |
336 | return(fdopen(handle, mode)); |
337 | } |
338 | |
339 | int |
340 | nw_feof(FILE *fp) |
341 | { |
342 | if(fp) |
343 | return (feof(fp)); |
344 | else |
345 | return -1; |
346 | } |
347 | |
348 | int |
349 | nw_ferror(FILE *fp) |
350 | { |
351 | if(fp) |
352 | return (ferror(fp)); |
353 | else |
354 | return -1; |
355 | } |
356 | |
357 | |
358 | int |
359 | nw_fflush(FILE *pf) |
360 | { |
361 | if(pf) |
362 | return fflush(pf); |
363 | else |
364 | return -1; |
365 | } |
366 | |
367 | int |
368 | nw_fgetpos(FILE *pf, fpos_t *p) |
369 | { |
370 | if(pf) |
371 | return fgetpos(pf, p); |
372 | else |
373 | return -1; |
374 | } |
375 | |
376 | char* |
377 | nw_fgets(char *s, int n, FILE *pf) |
378 | { |
379 | if(pf) |
380 | return(fgets(s, n, pf)); |
381 | else |
382 | return NULL; |
383 | } |
384 | |
385 | int |
386 | nw_fileno(FILE *pf) |
387 | { |
388 | if(pf) |
389 | return fileno(pf); |
390 | else |
391 | return -1; |
392 | } |
393 | |
394 | int |
395 | nw_flock(int fd, int oper) |
396 | { |
4d76e4b4 |
397 | dTHX; |
398 | Perl_croak(aTHX_ "The flock() function is not implemented on NetWare\n"); |
2986a63f |
399 | return 0; |
400 | } |
401 | |
402 | |
403 | FILE * |
404 | nw_fopen(const char *filename, const char *mode) |
405 | { |
406 | return (fopen(filename, mode)); |
407 | } |
408 | |
409 | int |
410 | nw_fputc(int c, FILE *pf) |
411 | { |
412 | if(pf) |
413 | return fputc(c,pf); |
414 | else |
415 | return -1; |
416 | } |
417 | |
418 | int |
419 | nw_fputs(const char *s, FILE *pf) |
420 | { |
421 | if(pf) |
422 | return fputs(s, pf); |
423 | else |
424 | return -1; |
425 | } |
426 | |
427 | size_t |
428 | nw_fread(void *buf, size_t size, size_t count, FILE *fp) |
429 | { |
430 | if(fp) |
431 | return fread(buf, size, count, fp); |
432 | else |
433 | return -1; |
434 | } |
435 | |
436 | FILE * |
437 | nw_freopen(const char *path, const char *mode, FILE *stream) |
438 | { |
439 | if(stream) |
440 | return freopen(path, mode, stream); |
441 | else |
442 | return NULL; |
443 | } |
444 | |
445 | int |
446 | nw_fseek(FILE *pf, long offset, int origin) |
447 | { |
448 | if(pf) |
449 | return (fseek(pf, offset, origin)); |
450 | else |
451 | return -1; |
452 | } |
453 | |
454 | int |
455 | nw_fsetpos(FILE *pf, const fpos_t *p) |
456 | { |
457 | if(pf) |
458 | return fsetpos(pf, p); |
459 | else |
460 | return -1; |
461 | } |
462 | |
463 | long |
464 | nw_ftell(FILE *pf) |
465 | { |
466 | if(pf) |
467 | return ftell(pf); |
468 | else |
469 | return -1; |
470 | } |
471 | |
472 | size_t |
473 | nw_fwrite(const void *buf, size_t size, size_t count, FILE *fp) |
474 | { |
475 | if(fp) |
476 | return fwrite(buf, size, count, fp); |
477 | else |
478 | return -1; |
479 | } |
480 | |
481 | long |
482 | nw_get_osfhandle(int fd) |
483 | { |
484 | return 0l; |
485 | } |
486 | |
487 | int |
488 | nw_getc(FILE *pf) |
489 | { |
490 | if(pf) |
491 | return getc(pf); |
492 | else |
493 | return -1; |
494 | } |
495 | |
496 | int |
497 | nw_putc(int c, FILE *pf) |
498 | { |
499 | if(pf) |
500 | return putc(c,pf); |
501 | else |
502 | return -1; |
503 | } |
504 | |
505 | int |
506 | nw_fgetc(FILE *pf) |
507 | { |
508 | if(pf) |
509 | return fgetc(pf); |
510 | else |
511 | return -1; |
512 | } |
513 | |
514 | int |
515 | nw_getpid(void) |
516 | { |
517 | return GetThreadGroupID(); |
518 | } |
519 | |
520 | int |
521 | nw_kill(int pid, int sig) |
522 | { |
523 | return 0; |
524 | } |
525 | |
526 | int |
527 | nw_link(const char *oldname, const char *newname) |
528 | { |
529 | return 0; |
530 | } |
531 | |
532 | long |
533 | nw_lseek(int fd, long offset, int origin) |
534 | { |
535 | return lseek(fd, offset, origin); |
536 | } |
537 | |
538 | int |
539 | nw_chdir(const char *dir) |
540 | { |
541 | return chdir(dir); |
542 | } |
543 | |
544 | int |
545 | nw_rmdir(const char *dir) |
546 | { |
547 | return rmdir(dir); |
548 | } |
549 | |
550 | DIR * |
551 | nw_opendir(char *filename) |
552 | { |
553 | char *buff = NULL; |
554 | int len = 0; |
555 | DIR *ret = NULL; |
556 | |
557 | len = strlen(filename); |
558 | buff = malloc(len + 5); |
559 | if (buff) { |
560 | strcpy(buff, filename); |
561 | if (buff[len-1]=='/' || buff[len-1]=='\\') { |
562 | buff[--len] = 0; |
563 | } |
564 | strcpy(buff+len, "/*.*"); |
565 | ret = opendir(buff); |
566 | free (buff); |
567 | buff = NULL; |
568 | return ret; |
569 | } else { |
570 | return NULL; |
571 | } |
572 | } |
573 | |
574 | int |
575 | nw_open(const char *path, int flag, ...) |
576 | { |
577 | va_list ap; |
578 | int pmode = -1; |
579 | |
580 | va_start(ap, flag); |
581 | pmode = va_arg(ap, int); |
582 | va_end(ap); |
583 | |
584 | if (stricmp(path, "/dev/null")==0) |
585 | path = "NUL"; |
586 | |
587 | return open(path, flag, pmode); |
588 | } |
589 | |
590 | int |
591 | nw_open_osfhandle(long handle, int flags) |
592 | { |
593 | return 0; |
594 | } |
595 | |
596 | unsigned long |
597 | nw_os_id(void) |
598 | { |
599 | return 0l; |
600 | } |
601 | |
602 | int nw_Pipe(int* a, int* e) |
603 | { |
604 | int ret = 0; |
605 | |
606 | errno = 0; |
607 | ret = pipe(a); |
608 | if(errno) |
609 | e = &errno; |
610 | |
611 | return ret; |
612 | } |
613 | |
614 | FILE* nw_Popen(char* command, char* mode, int* e) |
615 | { |
616 | int i = -1; |
617 | |
618 | FILE* ret = NULL; |
619 | PTEMPPIPEFILE ptpf = NULL; |
620 | |
621 | // this callback is supposed to call _popen, which spawns an |
622 | // asynchronous command and opens a pipe to it. The returned |
623 | // file handle can be read or written to; if read, it represents |
624 | // stdout of the called process and will return EOF when the |
625 | // called process finishes. If written to, it represents stdin |
626 | // of the called process. Naturally _popen is not available on |
627 | // NetWare so we must do some fancy stuff to simulate it. We will |
628 | // redirect to and from temp files; this has the side effect |
629 | // of having to run the process synchronously rather than |
630 | // asynchronously. This means that you will only be able to do |
631 | // this with CLIB NLMs built to run on the calling thread. |
632 | |
633 | errno = 0; |
634 | |
635 | ptpf1[iPopenCount] = (PTEMPPIPEFILE) malloc(sizeof(TEMPPIPEFILE)); |
636 | if (!ptpf1[iPopenCount]) |
637 | return NULL; |
638 | |
639 | ptpf = ptpf1[iPopenCount]; |
640 | iPopenCount ++; |
641 | if(iPopenCount > MAX_PIPE_RECURSION) |
642 | iPopenCount = MAX_PIPE_RECURSION; // Limit to the max no of pipes to be open recursively. |
643 | |
644 | fnTempPipeFile(ptpf); |
645 | ret = fnPipeFileOpen((PTEMPPIPEFILE) ptpf, (char *) command, (char *) mode); |
646 | if (ret) |
647 | File1[iPopenCount-1] = ret; // Store the obtained Pipe file handle. |
648 | else |
649 | { // Pipe file not obtained. So free the allocated memory. |
650 | if(ptpf1[iPopenCount-1]) |
651 | { |
652 | free(ptpf1[iPopenCount-1]); |
653 | ptpf1[iPopenCount-1] = NULL; |
654 | ptpf = NULL; |
655 | iPopenCount --; |
656 | } |
657 | } |
658 | |
659 | if (errno) |
660 | e = &errno; |
661 | |
662 | return ret; |
663 | } |
664 | |
665 | int nw_Pclose(FILE* file, int* e) |
666 | { |
667 | int i=0, j=0; |
668 | |
669 | errno = 0; |
670 | |
671 | if(file) |
672 | { |
673 | if(iPopenCount > 0) |
674 | { |
675 | for (i=0; i<iPopenCount; i++) |
676 | { |
677 | if(File1[i] == file) |
678 | { |
679 | // Delete the memory allocated corresponding to the file handle passed-in and |
680 | // also close the file corresponding to the file handle passed-in! |
681 | if(ptpf1[i]) |
682 | { |
683 | fnPipeFileClose(ptpf1[i]); |
684 | |
685 | free(ptpf1[i]); |
686 | ptpf1[i] = NULL; |
687 | } |
688 | |
689 | fclose(File1[i]); |
690 | File1[i] = NULL; |
691 | |
692 | break; |
693 | } |
694 | } |
695 | |
696 | // Rearrange the file pointer array |
697 | for(j=i; j<(iPopenCount-1); j++) |
698 | { |
699 | File1[j] = File1[j+1]; |
700 | ptpf1[j] = ptpf1[j+1]; |
701 | } |
702 | iPopenCount--; |
703 | } |
704 | } |
705 | else |
706 | return -1; |
707 | |
708 | if (errno) |
709 | e = &errno; |
710 | |
711 | return 0; |
712 | } |
713 | |
714 | |
715 | int |
716 | nw_vprintf(const char *format, va_list args) |
717 | { |
718 | return (vprintf(format, args)); |
719 | } |
720 | |
721 | int |
722 | nw_printf(const char *format, ...) |
723 | { |
724 | |
725 | va_list marker; |
726 | va_start(marker, format); /* Initialize variable arguments. */ |
727 | |
728 | return (vprintf(format, marker)); |
729 | } |
730 | |
731 | int |
732 | nw_read(int fd, void *buf, unsigned int cnt) |
733 | { |
734 | return read(fd, buf, cnt); |
735 | } |
736 | |
737 | struct direct * |
738 | nw_readdir(DIR *dirp) |
739 | { |
740 | DIR* ret=NULL; |
741 | |
742 | ret = readdir(dirp); |
743 | if(ret) |
744 | return((struct direct *)ret); |
745 | return NULL; |
746 | } |
747 | |
748 | int |
749 | nw_rename(const char *oname, const char *newname) |
750 | { |
751 | return(rename(oname,newname)); |
752 | } |
753 | |
754 | void |
755 | nw_rewinddir(DIR *dirp) |
756 | { |
acfe0abc |
757 | dTHX; |
4d76e4b4 |
758 | Perl_croak(aTHX_ "The rewinddir() function is not implemented on NetWare\n"); |
2986a63f |
759 | } |
760 | |
761 | void |
762 | nw_rewind(FILE *pf) |
763 | { |
764 | if(pf) |
765 | rewind(pf); |
766 | } |
767 | |
768 | void |
769 | nw_seekdir(DIR *dirp, long loc) |
770 | { |
acfe0abc |
771 | dTHX; |
4d76e4b4 |
772 | Perl_croak(aTHX_ "The seekdir() function is not implemented on NetWare\n"); |
2986a63f |
773 | } |
774 | |
775 | int * |
776 | nw_errno(void) |
777 | { |
778 | return (&errno); |
779 | } |
780 | |
781 | char *** |
782 | nw_environ(void) |
783 | { |
784 | return ((char ***)nw_getenviron()); |
785 | } |
786 | |
787 | char * |
788 | nw_strerror(int e) |
789 | { |
790 | return (strerror(e)); |
791 | } |
792 | |
793 | int |
794 | nw_isatty(int fd) |
795 | { |
796 | return(isatty(fd)); |
797 | } |
798 | |
799 | char * |
800 | nw_mktemp(char *Template) |
801 | { |
802 | return (fnMy_MkTemp(Template)); |
803 | } |
804 | |
805 | int |
806 | nw_chsize(int handle, long size) |
807 | { |
808 | return(chsize(handle,size)); |
809 | } |
810 | |
811 | #ifdef HAVE_INTERP_INTERN |
812 | void |
813 | sys_intern_init(pTHX) |
814 | { |
815 | |
816 | } |
817 | |
818 | void |
819 | sys_intern_clear(pTHX) |
820 | { |
821 | |
822 | } |
823 | |
824 | void |
825 | sys_intern_dup(pTHX_ struct interp_intern *src, struct interp_intern *dst) |
826 | { |
827 | |
828 | } |
829 | #endif /* HAVE_INTERP_INTERN */ |
830 | |
831 | void |
832 | Perl_init_os_extras(void) |
833 | { |
834 | |
835 | } |
836 | |
837 | void |
838 | Perl_nw5_init(int *argcp, char ***argvp) |
839 | { |
840 | MALLOC_INIT; |
841 | } |
842 | |
afbec6b0 |
843 | #ifdef USE_ITHREADS |
844 | PerlInterpreter * |
845 | perl_clone_host(PerlInterpreter* proto_perl, UV flags) |
846 | { |
847 | // Perl Clone is not implemented on NetWare. |
848 | return NULL; |
849 | } |
850 | #endif |
851 | |
2986a63f |
852 | // Some more functions: |
853 | |
854 | char * |
855 | nw_get_sitelib(const char *pl) |
856 | { |
857 | return (NULL); |
858 | } |
859 | |
860 | int |
861 | execv(char *cmdname, char **argv) |
862 | { |
863 | // This feature needs to be implemented. |
864 | // _asm is commented out since it goes into the internal debugger. |
865 | // _asm {int 3}; |
866 | return(0); |
867 | } |
868 | |
869 | int |
870 | execvp(char *cmdname, char **argv) |
871 | { |
872 | // This feature needs to be implemented. |
873 | // _asm is commented out since it goes into the internal debugger. |
874 | // _asm {int 3}; |
875 | return(0); |
876 | } |
877 | |
878 | int |
879 | do_aspawn(void *vreally, void **vmark, void **vsp) |
880 | { |
881 | // This feature needs to be implemented. |
882 | // _asm is commented out since it goes into the internal debugger. |
883 | // _asm {int 3}; |
fa03377f |
884 | //// return(0); |
885 | |
886 | |
887 | // This below code is required for system() call. |
888 | // Otherwise system() does not work on NetWare. |
889 | // Ananth, 3 Sept 2001 |
890 | |
891 | dTHX; |
892 | SV *really = (SV*)vreally; |
893 | SV **mark = (SV**)vmark; |
894 | SV **sp = (SV**)vsp; |
895 | char **argv; |
896 | char *str; |
897 | int status; |
898 | int flag = P_WAIT; |
899 | int index = 0; |
900 | |
901 | |
902 | if (sp <= mark) |
903 | return -1; |
904 | |
905 | nw_perlshell_items = 0; // No Shell |
906 | New(1306, argv, (sp - mark) + nw_perlshell_items + 3, char*); |
907 | |
908 | if (SvNIOKp(*(mark+1)) && !SvPOKp(*(mark+1))) { |
909 | ++mark; |
910 | flag = SvIVx(*mark); |
911 | } |
912 | |
913 | while (++mark <= sp) { |
914 | if (*mark && (str = (char *)SvPV_nolen(*mark))) |
915 | { |
916 | argv[index] = str; |
917 | index++; |
918 | } |
919 | else |
920 | { |
921 | argv[index] = ""; |
922 | // argv[index] = '\0'; |
923 | index++; |
924 | } |
925 | } |
926 | argv[index] = '\0'; |
927 | index++; |
928 | |
929 | status = nw_spawnvp(flag, |
930 | (char*)(really ? SvPV_nolen(really) : argv[0]), |
931 | (char**)argv); |
932 | |
933 | |
934 | if (flag != P_NOWAIT) { |
935 | if (status < 0) { |
936 | dTHR; |
937 | if (ckWARN(WARN_EXEC)) |
f98bc0c6 |
938 | Perl_warner(aTHX_ packWARN(WARN_EXEC), "Can't spawn \"%s\": %s", argv[0], strerror(errno)); |
fa03377f |
939 | status = 255 * 256; |
940 | } |
941 | else |
942 | status *= 256; |
943 | PL_statusvalue = status; |
944 | } |
945 | |
946 | Safefree(argv); |
947 | return (status); |
2986a63f |
948 | } |
949 | |
950 | int |
951 | do_spawn2(char *cmd, int exectype) |
952 | { |
953 | // This feature needs to be implemented. |
954 | // _asm is commented out since it goes into the internal debugger. |
955 | // _asm {int 3}; |
956 | return(0); |
957 | } |
958 | |
959 | int |
960 | do_spawn(char *cmd) |
961 | { |
962 | return do_spawn2(cmd, 2); |
963 | } |
964 | |
965 | int |
966 | fork(void) |
967 | { |
968 | return 0; |
969 | } |
970 | |