ez-ipupdate.c

Connect DDNS Client Use GNUDIP

static char *HN_fields_used[] = { "server", "user", "address", NULL };
static struct service_t HN_service = {
  SERV_HN,
  "hn",
  NULL,
  HN_update_entry,
  HN_check_info,
  HN_fields_used,
  HN_DEFAULT_SERVER,
  HN_DEFAULT_PORT,
  HN_REQUEST
};

int ZONEEDIT_update_entry(void);
int ZONEEDIT_check_info(void);
static char *ZONEEDIT_fields_used[] = { "server", "user", "address", "mx", "host", NULL };
static struct service_t ZONEEDIT_service = {
  SERV_ZONEEDIT,
  "zoneedit",
  NULL,
  ZONEEDIT_update_entry,
  ZONEEDIT_check_info,
  ZONEEDIT_fields_used,
  ZONEEDIT_DEFAULT_SERVER,
  ZONEEDIT_DEFAULT_PORT,
  ZONEEDIT_REQUEST
};

static struct service_t *service = &DEF_SERVICE;

int options;

#define OPT_DEBUG       0x0001
#define OPT_DAEMON      0x0004
#define OPT_QUIET       0x0008
#define OPT_FOREGROUND  0x0010
#define OPT_OFFLINE     0x0020

enum { 
  CMD__start = 1,
  CMD_service_type,
  CMD_server,
  CMD_user,
  CMD_address,
  CMD_wildcard,
  CMD_mx,
  CMD_max_interval,
  CMD_url,
  CMD_host,
  CMD_cloak_title,
  CMD_interface,
  CMD_retrys,
  CMD_resolv_period,
  CMD_period,
  CMD_daemon,
  CMD_debug,
  CMD_execute,
  CMD_foreground,
  CMD_quiet,
  CMD_timeout,
  CMD_run_as_user,
  CMD_connection_type,
  CMD_cache_file,
  CMD_notify_email,
  CMD_pid_file,
  CMD_offline,
  CMD__end
};

int conf_handler(struct conf_cmd *cmd, char *arg);
static struct conf_cmd conf_commands[] = {
  { CMD_address,         "address",         CONF_NEED_ARG, 1, conf_handler, "%s=<ip address>" },
  { CMD_cache_file,      "cache-file",      CONF_NEED_ARG, 1, conf_handler, "%s=<cache file>" },
  { CMD_cloak_title,     "cloak-title",     CONF_NEED_ARG, 1, conf_handler, "%s=<title>" },
  { CMD_daemon,          "daemon",          CONF_NO_ARG,   1, conf_handler, "%s=<command>" },
  { CMD_execute,         "execute",         CONF_NEED_ARG, 1, conf_handler, "%s=<shell command>" },
  { CMD_debug,           "debug",           CONF_NO_ARG,   1, conf_handler, "%s" },
  { CMD_foreground,      "foreground",      CONF_NO_ARG,   1, conf_handler, "%s" },
  { CMD_pid_file,        "pid-file",        CONF_NEED_ARG, 1, conf_handler, "%s=<file>" },
  { CMD_host,            "host",            CONF_NEED_ARG, 1, conf_handler, "%s=<host>" },
  { CMD_interface,       "interface",       CONF_NEED_ARG, 1, conf_handler, "%s=<interface>" },
  { CMD_mx,              "mx",              CONF_NEED_ARG, 1, conf_handler, "%s=<mail exchanger>" },
  { CMD_max_interval,    "max-interval",    CONF_NEED_ARG, 1, conf_handler, "%s=<number of seconds between updates>" },
  { CMD_notify_email,    "notify-email",    CONF_NEED_ARG, 1, conf_handler, "%s=<address to email if bad things happen>" },
  { CMD_offline,         "offline",         CONF_NO_ARG,   1, conf_handler, "%s" },
  { CMD_retrys,          "retrys",          CONF_NEED_ARG, 1, conf_handler, "%s=<number of trys>" },
  { CMD_server,          "server",          CONF_NEED_ARG, 1, conf_handler, "%s=<server name>" },
  { CMD_service_type,    "service-type",    CONF_NEED_ARG, 1, conf_handler, "%s=<service type>" },
  { CMD_timeout,         "timeout",         CONF_NEED_ARG, 1, conf_handler, "%s=<sec.millisec>" },
  { CMD_resolv_period,   "resolv-period",   CONF_NEED_ARG, 1, conf_handler, "%s=<time between failed resolve attempts>" },
  { CMD_period,          "period",          CONF_NEED_ARG, 1, conf_handler, "%s=<time between update attempts>" },
  { CMD_url,             "url",             CONF_NEED_ARG, 1, conf_handler, "%s=<url>" },
  { CMD_user,            "user",            CONF_NEED_ARG, 1, conf_handler, "%s=<user name>[:password]" },
  { CMD_run_as_user,     "run-as-user",     CONF_NEED_ARG, 1, conf_handler, "%s=<user>" },
  { CMD_wildcard,        "wildcard",        CONF_NO_ARG,   1, conf_handler, "%s" },
  { CMD_quiet,           "quiet",           CONF_NO_ARG,   1, conf_handler, "%s" },
  { CMD_connection_type, "connection-type", CONF_NEED_ARG, 1, conf_handler, "%s=<connection type>" },
  { 0, 0, 0, 0, 0 }
};

/**************************************************/

void print_usage( void );
void print_version( void );
void parse_args( int argc, char **argv );
int do_connect(int *sock, char *host, char *port);
void base64Encode(char *intext, char *output);
int main( int argc, char **argv );
void warn_fields(char **okay_fields);

/**************************************************/

void print_usage( void )
{
  fprintf(stdout, "usage: ");
  fprintf(stdout, "%s [options] \n\n", program_name);
  fprintf(stdout, " Options are:\n");
  fprintf(stdout, "  -a, --address <ip address>\tstring to send as your ip address\n");
  fprintf(stdout, "  -b, --cache-file <file>\tfile to use for caching the ipaddress\n");
  fprintf(stdout, "  -c, --config-file <file>\tconfiguration file, almost all arguments can be\n");
  fprintf(stdout, "\t\t\t\tgiven with: <name>[=<value>]\n\t\t\t\tto see a list of possible config commands\n");
  fprintf(stdout, "\t\t\t\ttry \"echo help | %s -c -\"\n", program_name);
  fprintf(stdout, "  -d, --daemon\t\t\trun as a daemon periodicly updating if \n\t\t\t\tnecessary\n");
#ifdef DEBUG
  fprintf(stdout, "  -D, --debug\t\t\tturn on debuggin\n");
#endif
  fprintf(stdout, "  -e, --execute <command>\tshell command to execute after a successful\n\t\t\t\tupdate\n");
  fprintf(stdout, "  -f, --foreground\t\twhen running as a daemon run in the foreground\n");
  fprintf(stdout, "  -F, --pidfile <file>\t\tuse <file> as a pid file\n");
  fprintf(stdout, "  -h, --host <host>\t\tstring to send as host parameter\n");
  fprintf(stdout, "  -i, --interface <iface>\twhich interface to use\n");
  fprintf(stdout, "  -L, --cloak_title <host>\tsome stupid thing for DHS only\n");
  fprintf(stdout, "  -m, --mx <mail exchange>\tstring to send as your mail exchange\n");
  fprintf(stdout, "  -M, --max-interval <# of sec>\tmax time in between updates\n");
  fprintf(stdout, "  -N, --notify-email <email>\taddress to send mail to if bad things happen\n");
  fprintf(stdout, "  -o, --offline\t\t\tset to off line mode\n");
  fprintf(stdout, "  -p, --resolv-period <sec>\tperiod to check IP if it can't be resolved\n");
  fprintf(stdout, "  -P, --period <# of sec>\tperiod to check IP in daemon \n\t\t\t\tmode (default: 1800 seconds)\n");
  fprintf(stdout, "  -q, --quiet \t\t\tbe quiet\n");
  fprintf(stdout, "  -r, --retrys <num>\t\tnumber of trys (default: 1)\n");
  fprintf(stdout, "  -R, --run-as-user <user>\tchange to <user> for running, be ware\n\t\t\t\tthat this can cause problems with handeling\n\t\t\t\tSIGHUP properly if that user can't read the\n\t\t\t\tconfig file\n");
  fprintf(stdout, "  -s, --server <server[:port]>\tthe server to connect to\n");
  fprintf(stdout, "  -S, --service-type <server>\tthe type of service that you are using\n");
  fprintf(stdout, "\t\t\t\ttry one of: %s\n", SERVICES_HELP_STR);
  fprintf(stdout, "  -t, --timeout <sec.millisec>\tthe amount of time to wait on I/O\n");
  fprintf(stdout, "  -T, --connection-type <num>\tnumber sent to TZO as your connection \n\t\t\t\ttype (default: 1)\n");
  fprintf(stdout, "  -U, --url <url>\t\tstring to send as the url parameter\n");
  fprintf(stdout, "  -u, --user <user[:passwd]>\tuser ID and password, if either is left blank \n\t\t\t\tthey will be prompted for\n");
  fprintf(stdout, "  -w, --wildcard\t\tset your domain to have a wildcard alias\n");
  fprintf(stdout, "      --help\t\t\tdisplay this help and exit\n");
  fprintf(stdout, "      --version\t\t\toutput version information and exit\n");
  fprintf(stdout, "      --credits\t\t\tprint the credits and exit\n");
  fprintf(stdout, "      --signalhelp\t\tprint help about signals\n");
  fprintf(stdout, "\n");
}

void print_version( void )
{
  fprintf(stdout, "%s: - %s - $Id: ez-ipupdate.c,v 1.44 2001/03/31 20:05:51 amackay Exp $\n", program_name, VERSION);
}

void print_credits( void )
{
  fprintf( stdout, "AUTHORS / CONTRIBUTORS\n"
      "  Angus Mackay <[e-mail]>\n"
      "  Jeremy Bopp <[e-mail]>\n"
      "  Mark Jeftovic <[e-mail]>\n"
      "  Stefaan Ponnet <[e-mail]>\n"
      "\n" );
}

void print_signalhelp( void )
{
  fprintf(stdout, "\nsignals are only really used when in daemon mode.\n\n");
  fprintf(stdout, "signals: \n");
  fprintf(stdout, "  HUP\t\tcauses it to re-read its config file\n");
  fprintf(stdout, "  TERM\t\twake up and possibly perform an update\n");
  fprintf(stdout, "  QUIT\t\tshutdown\n");
  fprintf(stdout, "\n");
}

#if HAVE_SIGNAL_H
RETSIGTYPE sigint_handler(int sig)
{
  char message[] = "interupted.\n";
  close(client_sockfd);
  write(2, message, sizeof(message)-1);

#if HAVE_GETPID
  if(pid_file)
  {
    pid_file_delete(pid_file);
  }
#endif

  exit(1);
}
RETSIGTYPE generic_sig_handler(int sig)
{
  last_sig = sig;
}
#endif

int get_duration(char *str)
{
  char *multchar;
  int mult;
  char save;
  int duration;

  for(multchar=str; *multchar != '\0'; multchar++);
  if(multchar != str) { multchar--; }
  if(*multchar == '\0' || isdigit(*multchar)) { mult = 1; multchar++; }
  else if(*multchar == 'M') { mult = 60; }
  else if(*multchar == 'H') { mult = 60*60; }
  else if(*multchar == 'd') { mult = 60*60*24; }
  else if(*multchar == 'w') { mult = 60*60*24*7; }
  else if(*multchar == 'f') { mult = 60*60*24*7*2; }
  else if(*multchar == 'm') { mult = 60*60*24*30; }
  else if(*multchar == 'y') { mult = 60*60*24*365; }
  else
  {
    fprintf(stderr, "invalid multiplier: %c\n", *multchar);
    fprintf(stderr, "valid multipliers:\n");
    fprintf(stderr, "  %c -> %s (%d)\n", 'M', "Minute",    60);
    fprintf(stderr, "  %c -> %s (%d)\n", 'H', "Hour",      60*60);
    fprintf(stderr, "  %c -> %s (%d)\n", 'd', "day",       60*60*24);
    fprintf(stderr, "  %c -> %s (%d)\n", 'w', "week",      60*60*24*7);
    fprintf(stderr, "  %c -> %s (%d)\n", 'f', "fortnight", 60*60*24*7*2);
    fprintf(stderr, "  %c -> %s (%d)\n", 'm', "month",     60*60*24*30);
    fprintf(stderr, "  %c -> %s (%d)\n", 'y', "year",      60*60*24*365);
    exit(1);
  }
  save = *multchar;
  *multchar = '\0';
  duration = strtol(str, NULL, 0) * mult;
  *multchar = save;

  return(duration);
}

/*
 * like "chomp" in perl, take off trailing newline chars
 */
char *chomp(char *buf)
{
  char *p;

  for(p=buf; *p != '\0'; p++);
  if(p != buf) { p--; }
  while(p>=buf && (*p == '\n' || *p == '\r'))
  {
    *p-- = '\0';
  }

  return(buf);
}

/*
 * show_message
 *
 * if we are running in daemon mode then log to syslog, if not just output to
 * stderr.
 *
 */
void show_message(char *fmt, ...)
{
  va_list args; 
  va_start(args, fmt);

  if(options & OPT_DAEMON && !(options & OPT_FOREGROUND))
  {
    char buf[MAX_MESSAGE_LEN];

#if defined(HAVE_VSPRINTF) || defined(HAVE_VSNPRINTF)
    vsnprintf(buf, sizeof(buf), fmt, args);
#else
    sprintf(buf, "message incomplete because your OS sucks: %s\n", fmt);
#endif

    syslog(LOG_NOTICE, buf);
  }
  else
  {
#ifdef HAVE_VFPRINTF
    vfprintf(stderr, fmt, args);
#else
    fprintf(stderr, "message incomplete because your OS sucks: %s\n", fmt);
#endif
  }

  va_end(args);
}

/*
 * returns true if the string passed in is an internet address in dotted quad
 * notation.
 */
int is_dotted_quad(char *addr)
{
  int q[4];
  char *p;
  int i;

  if(sscanf(addr, "%d.%d.%d.%d", &(q[0]), &(q[1]), &(q[2]), &(q[3])) != 4)
  {
    return(0);
  }
  
  if(q[0] > 255 || q[0] < 0 ||
      q[1] > 255 || q[1] < 0 ||
      q[2] > 255 || q[2] < 0 ||
      q[3] > 255 || q[3] < 0)
  {
    return(0);
  }

  /* we know there are 3 dots */
  p = addr;
  if(p != NULL) { p = strchr(p, '.'); p++; }
  if(p != NULL) { p = strchr(p, '.'); p++; }
  if(p != NULL) { p = strchr(p, '.'); }
  for(i=0; *p != '\0' && i<4; i++, p++);
  if(*p != '\0')
  {
    return(0);
  }

  return(1);
}

int option_handler(int id, char *optarg)
{
#if HAVE_PWD_H && HAVE_GRP_H
  struct passwd *pw;
#endif
  char *tmp;
  int i;

  switch(id)
  {
    case CMD_address:
      if(address) { free(address); }
      address = strdup(optarg);
      dprintf((stderr, "address: %s\n", address));
      break;

    case CMD_daemon:
      options |= OPT_DAEMON;
      dprintf((stderr, "daemon mode\n"));
      break;

    case CMD_debug:
#ifdef DEBUG
      options |= OPT_DEBUG;
      dprintf((stderr, "debugging on\n"));
#else
      fprintf(stderr, "debugging was not enabled at compile time\n");
#endif
      break;

    case CMD_execute:
#if defined(HAVE_WAITPID) || defined(HAVE_WAIT)
      if(post_update_cmd) { free(post_update_cmd); }
      post_update_cmd = malloc(strlen(optarg) + 1 + ARGLENGTH + 1);
      post_update_cmd_arg = post_update_cmd + strlen(optarg) + 1;
      sprintf(post_update_cmd, "%s ", optarg);
      dprintf((stderr, "post_update_cmd: %s\n", post_update_cmd));
#else
      fprintf(stderr, "command execution not enabled at compile time\n");
      exit(1);
#endif
      break;

    case CMD_foreground:
      options |= OPT_FOREGROUND;
      dprintf((stderr, "fork()ing off\n"));
      break;

    case CMD_pid_file:
#if HAVE_GETPID
      if(pid_file) { free(pid_file); }
      pid_file = strdup(optarg);
      dprintf((stderr, "pid file: %s\n", pid_file));
#else
      fprintf(stderr, "pid file support not enabled at compile time\n");
#endif
      break;

    case CMD_host:
      if(host) { free(host); }
      host = strdup(optarg);
      dprintf((stderr, "host: %s\n", host));
      break;

    case CMD_interface:
#ifdef IF_LOOKUP
      if(interface) { free(interface); }
      interface = strdup(optarg);
      dprintf((stderr, "interface: %s\n", interface));
#else
      fprintf(stderr, "interface lookup not enabled at compile time\n");
      exit(1);
#endif
      break;

    case CMD_mx:
      if(mx) { free(mx); }
      mx = strdup(optarg);
      dprintf((stderr, "mx: %s\n", mx));
      break;

    case CMD_max_interval:
      max_interval = get_duration(optarg);
      if(max_interval < MIN_MAXINTERVAL)
      {
        fprintf(stderr, "WARNING: max-interval of %d is too short, using %d\n",
            max_interval, MIN_MAXINTERVAL);
        max_interval = MIN_MAXINTERVAL;
      }
      dprintf((stderr, "max_interval: %d\n", max_interval));
      break;

    case CMD_notify_email:
      if(notify_email) { free(notify_email); }
      notify_email = strdup(optarg);
      dprintf((stderr, "notify_email: %s\n", notify_email));
      break;

    case CMD_offline:
      options |= OPT_OFFLINE;
      dprintf((stderr, "offline mode\n"));
      break;

    case CMD_period:
      update_period = get_duration(optarg);
      if(update_period < MIN_UPDATE_PERIOD)
      {
        fprintf(stderr, "WARNING: period of %d is too short, using %d\n",
            update_period, MIN_UPDATE_PERIOD);
        update_period = MIN_UPDATE_PERIOD;
      }
      dprintf((stderr, "update_period: %d\n", update_period));
      break;

    case CMD_resolv_period:
      resolv_period = get_duration(optarg);
      if(resolv_period < 1)
      {
        fprintf(stderr, "WARNING: period of %d is too short, using %d\n",
            resolv_period, 1);
        resolv_period = 1;
      }
      dprintf((stderr, "resolv_period: %d\n", resolv_period));
      break;

    case CMD_quiet:
      options |= OPT_QUIET;
      dprintf((stderr, "quiet mode\n"));
      break;

    case CMD_retrys:
      ntrys = atoi(optarg);
      dprintf((stderr, "ntrys: %d\n", ntrys));
      break;

    case CMD_server:
      if(server) { free(server); }
      server = strdup(optarg);
      tmp = strchr(server, ':');
      if(tmp)
      {
        *tmp++ = '\0';
        if(port) { free(port); }
        port = strdup(tmp);
      }
      dprintf((stderr, "server: %s\n", server));
      dprintf((stderr, "port: %s\n", port));
      break;

    case CMD_service_type:
      if(strcmp("ezip", optarg) == 0 || strcmp("ez-ip", optarg) == 0)
      {
        service = &EZIP_service;
      }
      else if(strcmp("pgpow", optarg) == 0 || 
          strcmp("penguinpowered", optarg) == 0)
      {
        service = &PGPOW_service;
      }
      else if(strcmp("dhs", optarg) == 0)
      {
        service = &DHS_service;
      }
      else if(strcmp("dyndns", optarg) == 0)
      {
        service = &DYNDNS_service;
      }
      else if(strcmp("dyndns-stat", optarg) == 0 ||
          strcmp("dyndns-static", optarg) == 0 ||
          strcmp("statdns", optarg) == 0)
      {
        service = &DYNDNS_STAT_service;
      }
      else if(strcmp("qdns", optarg) == 0)
      {
        service = &QDNS_service;
      }