#include "mbconfig.h"
#include <stdio.h>
#include <stdlib.h>
#include <termios.h>
#include "ac/getopt.h"
#include <errno.h>
#include <unistd.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <netdb.h>
#include <sys/un.h>
#include <string.h>
#include "sock.h"

Include dependency graph for autopilot.c:

Functions
static void	keys (FILE *fh)

static void	usage (void)

void	reset_input_mode (void)

void	set_input_mode (void)

int	send_message (const char *message)

int	main (int argc, char *argv[])

Variables
const unsigned short int	PORT = 5555

const char *	SERVERHOST = "localhost"

const char *	SERVERPATH = "/var/mbdyn/mbdyn.sock"

struct termios	saved_attributes

static int	sasl = 0

const char *	path = ((void*)0)

const char *	host = ((void*)0)

unsigned short int	port = 0

Function Documentation

static void keys ( FILE * fh )

static

Definition at line 67 of file autopilot.c.

Referenced by main(), and usage().

 {
         fprintf(fh,
                         "\tkeys:\n"
                         "\t\t'i':\tswitches the incremental mode on\n"
                         "\t\t'p':\tincrements the drive\n"
                         "\t\t'm':\tdecrements the drive\n"
                         "\t\t'^D':\tquits\n\n");
 }

int main	(	int	argc,
		char *	argv[]
	)

Definition at line 184 of file autopilot.c.

References c, getopt(), host, keys(), msg, optarg, optind, path, PORT, port, read(), send_message(), SERVERHOST, set_input_mode(), usage(), and verbose.

 {
         char *user = NULL;
         char *cred = NULL;
 
         char *increment = "1.";
         char *label = NULL;
 
         char c;
 
         char *auth = NULL;
         char *inc = NULL;
         char *plus = NULL;
         char *minus = NULL;
 
         char *mech = NULL;
 
         int verbose = 0;
 
         host = SERVERHOST;
         port = PORT;
 
         while (1) {
                 int opt;
 
                 opt = getopt(argc, argv, "D:h:m:p:P:Svw:Wx:");
 
                 if (opt == EOF) {
                         break;
                 }
 
                 switch (opt) {
                 case 'D':
                         user = optarg;
                         break;
 
                 case 'h':
                         host = optarg;
                         break;
 
                 case 'm':
                         mech = optarg;
 #ifndef HAVE_SASL2
                         fprintf(stderr, "SASL not supported\n");
 #endif /* ! HAVE_SASL2 */
                         break;
 
                 case 'p':
                         port = atoi(optarg);
                         break;
 
                 case 'P':
                         path = optarg;
                         break;
 
                 case 'S':
                         sasl++;
 #ifndef HAVE_SASL2
                         fprintf(stderr, "SASL not supported\n");
                         exit(EXIT_FAILURE);
 #endif /* ! HAVE_SASL2 */
                         break;
 
                 case 'v':
                         verbose++;
                         break;
 
                 case 'w':
                         cred = strdup(optarg);
                         break;
 
                 case 'W': {
                         char *tmp = getpass("password: ");
 
                         if (tmp) {
                                 cred = strdup(tmp);
                                 memset(tmp, '\0', strlen(tmp));
                         }
                         break;
                 }
 
                 case 'x':
                         increment = optarg;
                         break;
                 }
         }
 
         if (argc - optind < 1) {
                 usage();
                 exit(EXIT_SUCCESS);
         }
 
         label = argv[optind];
 
         /* messaggi: */
         if (!sasl) {
                 if (user) {
                         size_t l = strlen(user);
                         if (cred) {
                                 l += strlen(cred) + 7 + 11;
 
                                 auth = (char *)calloc(sizeof(char), l + 1);
                                 snprintf(auth, l + 1, "user: %s\npassword: %s\n", user, cred);
                         } else {
                                 l += 7;
 
                                 auth = (char *)calloc(sizeof(char), l + 1);
                                 snprintf(auth, l + 1, "user: %s\n", user);
                         }
                 }
         } else {
 #ifdef HAVE_SASL2
                 if (verbose) {
                         printf("initializing SASL data...\n");
                 }
 
                 mbdyn_sasl.use_sasl = MBDYN_SASL_CLIENT;
                 mbdyn_sasl.sasl_flags = MBDYN_SASL_FLAG_CRITICAL | MBDYN_SASL_FLAG_USERAUTHZ;
                 mbdyn_sasl.sasl_mech = mech;
                 mbdyn_sasl.sasl_user = user;
                 mbdyn_sasl.sasl_cred = cred;
                 mbdyn_sasl.sasl_hostname = host;
 
                 if (mbdyn_sasl_client_init(&mbdyn_sasl) != SASL_OK) {
                         fprintf(stderr, "SASL init failed\n");
                         exit(EXIT_FAILURE);
                 }
 #endif /* HAVE_SASL2 */
         }
 
         if (auth) {
                 size_t l = strlen(auth) + 8 + strlen(label) + 9 + 2;
 
                 inc = (char *)calloc(sizeof(char), l + 1);
                 snprintf(inc, l, "%slabel: %s\ninc: yes\n.\n", auth, label);
 
                 l = strlen(auth) + 8 + strlen(label) + 8 + strlen(increment) + 2;
                 plus = (char *)calloc(sizeof(char), l + 1);
                 minus = (char *)calloc(sizeof(char), l + 1 + 1);
                 snprintf(plus, l + 1, "%slabel: %s\nvalue: %s\n.\n", auth, label, increment);
                 snprintf(minus, l + 2, "%slabel: %s\nvalue: -%s\n.\n", auth, label, increment);
 
         } else {
                 size_t l = 8 + strlen(label) + 9 + 2;
                 
                 inc = (char *)calloc(sizeof(char), l + 1);
                 snprintf(inc, l + 1, "label: %s\ninc: yes\n.\n", label);
 
                 l = 8 + strlen(label) + 8 + strlen(increment) + 2;
                 plus = (char *)calloc(sizeof(char), l + 1);
                 minus = (char *)calloc(sizeof(char), l + 1 + 1);
                 snprintf(plus, l + 1, "label: %s\nvalue: %s\n.\n", label, increment);
                 snprintf(minus, l + 2, "label: %s\nvalue: -%s\n.\n", label, increment);
         }
 
         set_input_mode();
 
         if (verbose) {
                 fprintf(stdout, "Connecting to host %s:%d\n", host, port);
                 if (user) {
                         if (cred) {
                                 fprintf(stdout, "Accounting as \"%s\" (with creds)\n", user);
                         
                         } else {
                                 fprintf(stdout, "Accounting as \"%s\"\n", user);
                         }
                 }
                 fprintf(stdout, "Incrementing drive %s by %s\n", label, increment);
                 keys(stdout);
         }
 
         while (1) {
                 size_t i;
 
                 i = read(STDIN_FILENO, &c, 1);
 
                 if (i > 0) {
                         char    *msg = NULL;
 
                         if (c == '\004') {         /* `C-d' */
                                 break;
                         }
 
                         switch (c) {
                         case 'i':
                                 msg = inc;
                                 break;
 
                                 break;
 
                         case 'p':
                                 msg = plus;
                                 break;
 
                         case 'm':
                                 msg = minus;
                                 break;
 
                         }
 
                         if (send_message(msg) == -1) {
                                 fprintf(stderr, "unable to connect to host %s:%d\n",
                                                 host, port);
                         }
                 }
         }
 
         if (cred) {
                 free(cred);
         }
 
         exit(EXIT_SUCCESS);
 }

Here is the call graph for this function:

void reset_input_mode ( void )

Definition at line 105 of file autopilot.c.

References saved_attributes.

Referenced by set_input_mode().

 {
         tcsetattr(STDIN_FILENO, TCSANOW, &saved_attributes);
 }

int send_message ( const char * message )

Definition at line 146 of file autopilot.c.

References host, mbdyn_make_inet_socket(), mbdyn_make_named_socket(), path, and port.

Referenced by main().

 {
         int sock;
         struct sockaddr_in peer_name;
         FILE *fd;
 
         /* Create the socket. */
         if (path) {
                 sock = mbdyn_make_named_socket(0, path, 0, NULL);
         } else {
                 sock = mbdyn_make_inet_socket(0, host, port, 0, NULL);
         }
         if (sock < 0) {
                 return -1;
         }
 
         /* Connect to the server. */
         if (0 > connect(sock, (struct sockaddr *) &peer_name,
                                 sizeof(peer_name))) {
                 return -1;
         }
 
         if (sasl) {
 #ifdef HAVE_SASL2
                 if (mbdyn_sasl_client_auth(sock, NULL, &mbdyn_sasl) != SASL_OK) {
                         return -1;
                 }
 #endif /* HAVE_SASL2 */
         }
 
         fd = fdopen(sock, "w");
         fputs(message, fd);
         fclose(fd);
 
         return 0;
 }

Here is the call graph for this function:

void set_input_mode ( void )

Definition at line 111 of file autopilot.c.

References reset_input_mode(), and saved_attributes.

Referenced by main().

 {
         struct termios tattr;
 
         /* Make sure stdin is a terminal. */
         if (!isatty(STDIN_FILENO)) {
                 fprintf(stderr, "Not a terminal.\n");
                 exit(EXIT_FAILURE);
         }
 
         /* Save the terminal attributes so we can restore them later. */
         tcgetattr(STDIN_FILENO, &saved_attributes);
         atexit(reset_input_mode);
 
         /* Set the funny terminal modes. */
         tcgetattr(STDIN_FILENO, &tattr);
         tattr.c_lflag &= ~(ICANON|ECHO); /* Clear ICANON and ECHO. */
         tattr.c_cc[VMIN] = 0;
         tattr.c_cc[VTIME] = 0;
         if (tcsetattr(STDIN_FILENO, TCSAFLUSH, &tattr) < 0) {
                 perror("tcsetattr");
                 exit(EXIT_FAILURE);
         }
 }

Here is the call graph for this function:

static void usage ( void )

static

Definition at line 78 of file autopilot.c.

References keys().

Referenced by main().

 {
         fprintf(stderr,
                         "\n\tusage: autopilot [h:p:D:vw:Wx:] <label>\n\n"
                         "\t\t-D <user>\tuser name\n"
                         "\t\t-h <host>\thost name\n"
                         "\t\t-m <mech>\tSASL mechanism(s)\n"
                         "\t\t-p <port>\tport number\n"
                         "\t\t-P <path>\tpath for named socked\n"
                         "\t\t-S\t\tuse SASL"
 #ifndef HAVE_SASL2
                                 " (not supported)"
 #endif /* ! HAVE_SASL2 */
                         "\n"
                         "\t\t-v\t\tverbose\n"
                         "\t\t-w <cred>\tuser credentials\n"
                         "\t\t-W\t\tprompt for user credentials\n"
                         "\t\t-x <value>\tincrement\n"
                         "\n"
                         "\t\t<label>:\tfile drive (base 1) index to modify\n\n");
         keys(stderr);
 }