home *** CD-ROM | disk | FTP | other *** search
/ NetNews Usenet Archive 1993 #3 / NN_1993_3.iso / spool / comp / os / vxworks / 1253 < prev    next >
Encoding:
Text File  |  1993-01-28  |  8.9 KB  |  414 lines
  1. Path: sparky!uunet!scifi!acheron!philabs!linus!agate!dog.ee.lbl.gov!lbl.gov!vxwexplo
  2. From: zander@luke.atdiv.lanl.gov (Mark Zander)
  3. Newsgroups: comp.os.vxworks
  4. Subject: re: Executing shell scripts
  5. Date: Thu, 28 Jan 93 12:20:31 MST
  6. Organization: Lawrence Berkeley Laboratory, Berkeley CA
  7. Lines: 401
  8. Sender: vxwexplo@lbl.gov
  9. Message-ID: <9301281920.AA13272@luke.atdiv.lanl.gov>
  10. NNTP-Posting-Host: 128.3.112.16
  11. Originator: daemon@vxw.ee.lbl.gov
  12.  
  13. Sorry it took so long, but I wanted to clear this before sending it.
  14.  
  15. Brian Quigley writes:
  16.  
  17. > I've got a need to execute a shell script from within a program I'm
  18. > working on.  I figured I'd copy the startup shell script code since it
  19. > does what I want.  Unfortunately, the code that I took from usrConfig.c
  20. > does not behave the same when I put it my code.  The script does not execute.  
  21. > 
  22. > I've tried killing any existing shell before I start the new one. This
  23. > doesn't seem to help.  Various messing with ioTaskSetStd, 
  24. > shellOrigStdSet, and ioGlobalStdSet produce undesirable results.
  25. > 
  26. > Any hints would be appreciated.
  27. > 
  28. > Thanks.
  29. > 
  30. > (P.S. Hints for a Unix like "system()" call would also be appreciated.)
  31.  
  32. I've had a similar need to execute shell scripts from a unix shell.
  33. The following code worked for that purpose.  I hope it can help you
  34. as well.  Good luck!
  35.  
  36. /*    r s h d . c
  37. *
  38. *************************************************************************
  39. *
  40. *                L O S   A L A M O S
  41. *            Los Alamos National Laboratory
  42. *             Los Alamos, New Mexico 87545
  43. *
  44. *    File Name:            rshd.c
  45. *    Environment:        VxWorks V4.0
  46. *    Developement:        Sun C, Sun OS 4.0, Sun 3/60
  47. *    Make Description:
  48. *
  49. *
  50. *    Modification History
  51. *    ------------ -------
  52. *
  53. *    Date        Programmer        Comments
  54. *    ----        ----------        --------
  55. *
  56. *    1-Jun-90    Mark Zander        Borrowed from telnetLib
  57. *
  58. *************************************************************************
  59. */
  60.  
  61. /*
  62. *       Source Code Control System Identifier
  63. */
  64. static char SccsId[ ] = "@(#)rshd.c    1.1    11/20/91";
  65. /*
  66. *************************************************************************
  67. *++
  68. *    Name
  69. *    ----
  70. *
  71. *>>    rshd    - remote shell daemon for vxWorks
  72. *
  73. *    Purpose
  74. *    -------
  75. *
  76. *
  77. *    Subroutine List
  78. *    ---------- ----
  79. *
  80. *    rshInit        - initialize remote shell daemon
  81. *    rshd        - remote shell daemon
  82. *
  83. *    Include Files
  84. *    ------- -----
  85. *
  86. *
  87. *
  88. *    See Also
  89. *    --- ----
  90. *
  91. *
  92. *--
  93. *************************************************************************
  94. */
  95. #include    "vxWorks.h"
  96. #include    "types.h"
  97. #include    "socket.h"
  98. #include    "in.h"
  99. #include    "ioLib.h"
  100. #include    "taskLib.h"
  101.  
  102. /* login       513/tcp */
  103. /* shell       514/tcp     cmd     # no passwords used */
  104.  
  105. #define        RSH_SERVICE            514                /* shell port number */
  106.  
  107. #define        STDIN_BUF_SIZE        512
  108.  
  109. static int    rshTaskOptions        = VX_SUPERVISOR_MODE | VX_UNBREAKABLE;
  110. static int    rshTaskStackSize    = 1500;
  111. static int    rshTaskPriority        = 2;
  112.  
  113. int            rshdId;                                /* task id of rshd task */
  114.  
  115. static char    *rshShellName        = "shell";
  116.  
  117. static char    *ptyRshName            = "/pty/rsh.";
  118. static char    *ptyRshNameM        = "/pty/rsh.M";    /* master side */
  119. static char    *ptyRshNameS        = "/pty/rsh.S";    /* slave side */
  120.  
  121. VOID rshd( );
  122.  
  123. /*
  124. *************************************************************************
  125. *+
  126. *    Name
  127. *    ----
  128. *
  129. *>    rshInit        - initialize remote shell daemon
  130. *
  131. *    Purpose
  132. *    -------
  133. *
  134. *    Remote shell initialize.
  135. *
  136. *    Calling Sequence
  137. *    ------- --------
  138. *
  139. *    rshInit( );
  140. *
  141. *-
  142. *************************************************************************
  143. */
  144. VOID rshInit( )
  145.  
  146. {
  147.     static BOOL done = FALSE;    /* FALSE = not done */
  148.  
  149.     if ( done ) {
  150.         printErr( "rshInit: already initialized.\n" );
  151.         return;
  152.     }
  153.  
  154.     if ( ptyDrv( ) == ERROR ||
  155.             ptyDevCreate( ptyRshName, 1024, 1024 ) == ERROR ) {
  156.         printErr ("rshInit: unable to create pty device.\n");
  157.         return;
  158.     }
  159.  
  160.     rshdId = taskSpawn( "rshd", rshTaskPriority,
  161.                         rshTaskOptions, rshTaskStackSize,
  162.                         rshd, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 );  
  163.  
  164.     if ( rshdId == ERROR ) {
  165.         printErr( "rshInit: unable to spawn rshd.\n" );
  166.     } else {
  167.         done = TRUE;
  168.     }
  169. }
  170.  
  171. /*
  172. *************************************************************************
  173. *+
  174. *    Name
  175. *    ----
  176. *
  177. *>    rshd        - remote shell daemon
  178. *
  179. *    Purpose
  180. *    -------
  181. *
  182. *    Remote shell daemon.  Similar to telnetd.  Executes a shell command sent
  183. *    via the shell socket from another machine.  Does not redirect input or
  184. *    output of the given command and for this reason requires a special version
  185. *    of the unix rshell command.  Started from routine "rshInit".
  186. *
  187. *    Calling Sequence
  188. *    ------- --------
  189. *
  190. *    rshd( );
  191. *-
  192. *************************************************************************
  193. */
  194. VOID rshd( )
  195.  
  196. {
  197.     int                    optval;
  198.     struct sockaddr_in    myAddress;
  199.     struct sockaddr_in    clientAddress;
  200.     int                    clientAddrLen;
  201.     int                    client;
  202.     int                    masterFd;
  203.     int                    slaveFd;
  204.     int                    sd;
  205.     char                buf[ STDIN_BUF_SIZE ];
  206.     int                    n;
  207.     int                    shellInFd;
  208. /*
  209. *    Open a socket and wait for a client
  210. */
  211.     sd = socket( AF_INET, SOCK_STREAM, 0 );
  212.    
  213.     bzero( (char *) &myAddress, sizeof( myAddress ) );
  214.     myAddress.sin_family = AF_INET;
  215.     myAddress.sin_port   = RSH_SERVICE;
  216.  
  217.     if ( bind( sd, (struct sockaddr *) &myAddress, sizeof( myAddress ) )
  218.             == ERROR ) {
  219.         printErr( "rshd: bind failed.\n" );
  220.         return;
  221.     }
  222.  
  223.     listen( sd, 5 );
  224.  
  225.     FOREVER {
  226. /*
  227. *    Wait for shell to exist
  228. */
  229.         while ( taskNameToId( rshShellName ) == ERROR ) {
  230.             taskDelay( sysClkRateGet( ) );
  231.         }
  232.         errnoSet( OK );        /* clear errno for pretty i() display */
  233. /*
  234. *    Now accept connection
  235. */
  236.         clientAddrLen = sizeof( clientAddress );
  237.         client = accept( sd, (struct sockaddr *) &clientAddress, &clientAddrLen );
  238.  
  239.         if ( client == ERROR ) {
  240.             printErr( "rshd: accept failed - status = 0x%x\n", errnoGet( ) );
  241.             continue;
  242.         }
  243. /*
  244. *    create the pseudo terminal:
  245. *        the master side is connected to the socket to the remote machine
  246. */
  247.  
  248.         if ( ( masterFd = open( ptyRshNameM, WRITE ) ) == ERROR ) {
  249.             char *msg = "\r\nSorry, trouble with pty.\r\n";
  250.  
  251.             printErr( "rshd: error opening %s\n", ptyRshNameM );
  252.             write( client, msg, strlen( msg ) );
  253.             close( client );
  254.             continue;
  255.         }
  256.  
  257.         if ( ( slaveFd = open( ptyRshNameS, READ ) ) == ERROR ) {
  258.             char *msg = "\r\nSorry, trouble with pty.\r\n";
  259.  
  260.             printErr( "rshd: error opening %s\n", ptyRshNameS );
  261.             write( client, msg, strlen( msg ) );
  262.             close( client );
  263.             close( masterFd );
  264.             continue;
  265.         }
  266. /*
  267. *    Set up slave
  268. */
  269.         ioctl( slaveFd, FIOOPTIONS, OPT_RAW );
  270.         ioctl( slaveFd, FIOFLUSH );
  271. /*
  272. *    Save original standard in of shell
  273. */
  274.         shellInFd  = ioGlobalStdGet( STD_IN );
  275. /*
  276. *    Redirect standard in of shell
  277. */
  278.         shellOrigStdSet( STD_IN, slaveFd );
  279. /*
  280. *    Restart shell so it'll accept this command
  281. */
  282.         taskRestart( taskNameToId( rshShellName ) );
  283. /*
  284. *    Get command form remote host and send it to shell
  285. */
  286.         if ( ( n = read( client, buf, sizeof( buf ) ) ) > 0 ) {
  287.             buf[n] = 0;
  288.             write( masterFd, buf, n );
  289.         }
  290. /*
  291. *    Set shell back to orginal standard in
  292. */
  293.         shellOrigStdSet( STD_IN, shellInFd );
  294. /*
  295. *    Close connections to shell and remote host
  296. */
  297.         close( masterFd );
  298.         close( slaveFd );
  299.         close( client );
  300.     }
  301. }
  302.  
  303.  
  304. /*    v s h . c
  305. *
  306. *************************************************************************
  307. *
  308. *                L O S   A L A M O S
  309. *            Los Alamos National Laboratory
  310. *             Los Alamos, New Mexico 87545
  311. *
  312. *    File Name:            vsh.c
  313. *    Environment:        VxWorks V4.0
  314. *    Developement:        Sun C, Sun OS 4.0, Sun 3/60
  315. *    Make Description:
  316. *
  317. *
  318. *    Modification History
  319. *    ------------ -------
  320. *
  321. *    Date        Programmer        Comments
  322. *    ----        ----------        --------
  323. *
  324. *    4-Jun-90    Mark Zander        Original
  325. *    21-Nov-91    me                change name from rsh to vsh to avoid name
  326. *                                clashes
  327. *
  328. *************************************************************************
  329. */
  330.  
  331. /*
  332. *************************************************************************
  333. *+
  334. *    Name
  335. *    ----
  336. *
  337. *>    vsh        - execute remote shell command on a vxWorks system
  338. *
  339. *    Purpose
  340. *    -------
  341. *
  342. *    Executes a remote shell command for a vxWorks system.  Sends one command
  343. *    over the shell socket.  Is similar to the unix rsh command but does not
  344. *    redirect stdin and stdout.
  345. *
  346. *    Command
  347. *    -------
  348. *
  349. *    % vsh hostname cmd
  350. *
  351. *    or
  352. *
  353. *    % vsh
  354. *    Host name? hostname
  355. *    Command? cmd
  356. *
  357. *    Arguments
  358. *    ---------
  359. *
  360. *    hostname    name of host listed in yp directory
  361. *    cmd            remote command to be executed
  362. *
  363. *    Example
  364. *    -------
  365. *
  366. *
  367. *    Special Comments
  368. *    ------- --------
  369. *
  370. *
  371. *    See Also
  372. *    --- ----
  373. *
  374. *
  375. *-
  376. *************************************************************************
  377. */
  378. #include <string.h>
  379.  
  380. #define        RSH_SERVICE            514                /* shell port number */
  381. /*
  382. *    Source Code Control System Identifier
  383. */
  384. static char SccsId[ ] = "@(#)vsh.c    1.3    11/21/91";
  385.  
  386. void main(argc, argv)
  387. /*
  388. *    Arguments
  389. */
  390.     int            argc;                /* command line argument count */
  391.     char        **argv;                /* command line arguments */
  392. {
  393. /*
  394. *    Variables
  395. */
  396.     int            argin;                /* argument index */
  397.     char        hostname[100];        /* host name */
  398.     char        cmd[300];            /* remote command */
  399.     int            sock;                /* socket */
  400.     int            i;                    /* iteration counter */
  401.  
  402.     argin = 1;
  403.     getarg("Host name? ", argc, argv, &argin, hostname);
  404.     getarg("Command? ", argc, argv, &argin, cmd);
  405.     for (i = argin; i < argc; i++) {
  406.         strcat(cmd, " ");
  407.         strcat(cmd, argv[i]);
  408.     }
  409.     strcat(cmd, "\n");
  410.     sock = socClient(hostname, RSH_SERVICE);
  411.     write(sock, cmd, strlen(cmd));
  412.     close(sock);
  413. }
  414.