webcam.c

camE 1.9 for Linux - camE is an imlib2 webcam grabber, annotator, and uploader.

            file);
        break;
      case IMLIB_LOAD_ERROR_TOO_MANY_SYMBOLIC_LINKS:
        camlog("Error saving image %s - Too many levels of symbolic links",
            file);
        break;
      case IMLIB_LOAD_ERROR_OUT_OF_MEMORY:
        camlog("Error saving image %s - Out of memory", file);
        break;
      case IMLIB_LOAD_ERROR_OUT_OF_FILE_DESCRIPTORS:
        gib_eprintf("While loading %s - Out of file descriptors", file);
        break;
      case IMLIB_LOAD_ERROR_PERMISSION_DENIED_TO_WRITE:
        camlog("Error saving image %s - Cannot write to directory", file);
        break;
      case IMLIB_LOAD_ERROR_OUT_OF_DISK_SPACE:
        camlog("Error saving image %s - Cannot write - out of disk space", file);
        break;
      default:
        camlog
          ("Error saving image %s - Unknown error (%d). Attempting to continue",
           file, err);
        break;
    }
    return 0;
  }
  return 1;
}

void
draw_overlay(Imlib_Image image)
{
  int w, h;

  w = gib_imlib_image_get_width(overlay_im);
  h = gib_imlib_image_get_height(overlay_im);
  gib_imlib_blend_image_onto_image(image, overlay_im, 0, 0, 0, w, h,
                                   overlay_x, overlay_y, w, h, 0,
                                   gib_imlib_image_has_alpha(overlay_im), 0);
};

void
bw_res_change(struct timeval diff)
{
  int temp = 0;

  if (v_curr == -1) {

    while (temp < 5) {
      if (grab_buf.height == v_height[temp])
        v_curr = temp;
      temp++;
    }
    if (v_curr == -1) {
      bw_percent = 100;
      fprintf(stderr,
              "You don't appear to be running any of the resolutions\n");
      fprintf(stderr,
              "req'd by the bandwidth limiter. It has been deactivated.\n");
      camlog("method bw_percent killed, not at support'd res\n");
    }
  }

  if (float_timeval(diff) > (grab_delay * bw_percent) / 100) {
    camlog("bw_res_change Not enough bandwidth.\n");
    if (v_force < -1 && v_curr > 0) {
      camlog("bw_res_change Reducing image resolution.\n");
      grab_buf.height = v_height[--v_curr];
      grab_buf.width = v_width[v_curr];
    }
    v_force--;
  } else if (float_timeval(diff) < (grab_delay * bw_percent) / 200) {
    if (v_force > 1 && v_curr < 5) {
      camlog("bw_res_change Increasing image resolution.\n");
      grab_buf.height = v_height[++v_curr];
      grab_buf.width = v_width[v_curr];
    }
    v_force++;
  } else
    v_force = 0;
}


/* upload local to tmp then MV to remote */
void
ftp_upload(char *local,
           char *remote,
           char *tmp)
{
  char buf[2096];
  FILE *infile;
  CURLcode ret;
  struct stat st;
  static struct curl_slist *post_commands = NULL;
  static char *passwd_string = NULL;
  static char *url_string = NULL;

  infile = fopen(local, "r");

  if (!infile) {
    camlog("camE: Couldn't open temp file to upload it\n");
    perror("ftp_upload(): ");
    return;
  }
  fstat(fileno(infile), &st);

  if (!post_commands) {
    if (ftp_delete_first) {
      snprintf(buf, sizeof(buf), "dele %s", remote);
      post_commands = curl_slist_append(post_commands, buf);
    }
    snprintf(buf, sizeof(buf), "rnfr %s", tmp);
    post_commands = curl_slist_append(post_commands, buf);
    snprintf(buf, sizeof(buf), "rnto %s", remote);
    post_commands = curl_slist_append(post_commands, buf);
  }

  /* init the curl session */
  if (connections < 1) {
    curl_handle = curl_easy_init();
    connections++;

    if (passwd_string)
      free(passwd_string);
    passwd_string = gib_strjoin(":", ftp_user, ftp_pass, NULL);
    curl_easy_setopt(curl_handle, CURLOPT_USERPWD, passwd_string);

    /* set URL to save to */
    if (url_string)
      free(url_string);
    url_string = gib_strjoin("/", "ftp:/", ftp_host, ftp_dir, tmp, NULL);
    curl_easy_setopt(curl_handle, CURLOPT_URL, url_string);

    /* no progress meter please */
    curl_easy_setopt(curl_handle, CURLOPT_NOPROGRESS, 1);

    /* shut up completely */
    if (ftp_debug)
      curl_easy_setopt(curl_handle, CURLOPT_VERBOSE, 1);
    else
      curl_easy_setopt(curl_handle, CURLOPT_MUTE, 1);

    curl_easy_setopt(curl_handle, CURLOPT_UPLOAD, 1);

    if (!ftp_passive)
      curl_easy_setopt(curl_handle, CURLOPT_FTPPORT, ftp_interface);

    curl_easy_setopt(curl_handle, CURLOPT_POSTQUOTE, post_commands);
  }

  curl_easy_setopt(curl_handle, CURLOPT_INFILE, infile);
  curl_easy_setopt(curl_handle, CURLOPT_INFILESIZE, st.st_size);

  /* get it! */
  ret = curl_easy_perform(curl_handle);
  /* TODO check error */
  if (ret) {
    fprintf(stderr, "\ncamE: error sending via ftp: ");
    camlog("camE error: ");
    switch (ret) {
      case CURLE_URL_MALFORMAT:
        fprintf(stderr, "Badly formatted ftp host or directory\n");
        camlog("Badly formatted ftp host or directory\n");
        break;
      case CURLE_URL_MALFORMAT_USER:
        fprintf(stderr, "Badly formatted ftp username\n");
        camlog("Badly formatted ftp username\n");
        break;
      case CURLE_COULDNT_RESOLVE_PROXY:
        fprintf(stderr, "Couldn't resolve proxy\n");
        camlog("Couldn't resolve proxy\n");
        break;
      case CURLE_COULDNT_RESOLVE_HOST:
        fprintf(stderr, "Unable to resolve ftp host\n");
        camlog("Unable to resolve ftp host\n");
        break;
      case CURLE_COULDNT_CONNECT:
        fprintf(stderr, "Unable to connect to ftp host\n");
        camlog("Unable to connect to ftp host\n");
        break;
      case CURLE_FTP_WEIRD_SERVER_REPLY:
        fprintf(stderr, "Wierd server reply detected\n");
        camlog("Wierd server reply detected\n");
        break;
      case CURLE_FTP_ACCESS_DENIED:
        fprintf(stderr, "Access denied to ftp upload\n");
        camlog("Access denied to ftp upload\n");
        break;
      case CURLE_FTP_USER_PASSWORD_INCORRECT:
        fprintf(stderr, "Incorrect password for ftp login\n");
        camlog("Incorrect password for ftp login\n");
        break;
      case CURLE_FTP_WEIRD_PASS_REPLY:
        fprintf(stderr, "Wierd password reply from server\n");
        camlog("Wierd password reply from server\n");
        break;
      case CURLE_FTP_WEIRD_USER_REPLY:
        fprintf(stderr, "Wierd user reply from server\n");
        camlog("Wierd user reply from server\n");
        break;
      case CURLE_FTP_WEIRD_PASV_REPLY:
        fprintf(stderr, "Wierd passive reply from server\n");
        camlog("Wierd passive reply from server\n");
        break;
      case CURLE_FTP_CANT_GET_HOST:
        fprintf(stderr, "No route to host\n");
        camlog("No route to host\n");
        break;
      case CURLE_FTP_COULDNT_SET_BINARY:
        fprintf(stderr, "Couldn't set binary mode\n");
        camlog("Couldn't set binary mode\n");
        break;
      case CURLE_PARTIAL_FILE:
        fprintf(stderr, "Only partial file uploaded\n");
        camlog("Only partial file uploaded\n");
        break;
      case CURLE_FTP_WRITE_ERROR:
        fprintf(stderr, "Write error\n");
        camlog("Write error\n");
        break;
      case CURLE_FTP_QUOTE_ERROR:
        fprintf(stderr, "Misquoted ftp command - check ftp config\n");
        camlog("Misquoted ftp command - check ftp config\n");
        break;
      case CURLE_WRITE_ERROR:
        fprintf(stderr, "Write error\n");
        camlog("Write error\n");
        break;
      case CURLE_MALFORMAT_USER: /* the user name is illegally specified */
        fprintf(stderr, "Malformatted username\n");
        camlog("Malformatted username\n");
        break;
      case CURLE_FTP_COULDNT_STOR_FILE: /* failed FTP upload */
        fprintf(stderr, "Couldn't STOR the file\n");
        camlog("Couldn't STOR the file\n");
        break;
      case CURLE_READ_ERROR: /* could open/read from file */
        fprintf(stderr, "Couldn't open temp file\n");
        camlog("Couldn't open temp file\n");
        break;
      case CURLE_OUT_OF_MEMORY:
        fprintf(stderr, "Out of memory\n");
        camlog("Out of memory\n");
        break;
      case CURLE_OPERATION_TIMEOUTED: /* the timeout time was reached */
        fprintf(stderr, "Upload timed out\n");
        camlog("Upload timed out\n");
        break;
      case CURLE_FTP_PORT_FAILED: /* FTP PORT operation failed */
        fprintf(stderr, "ftp PORT failed\n");
        camlog("ftp PORT failed\n");
        break;
      case CURLE_FILE_COULDNT_READ_FILE:
        fprintf(stderr, "Couldn't read temp file\n");
        camlog("Couldn't read temp file\n");
        break;
      default:
        fprintf(stderr, "unknown error, attempting to continue\n");
        camlog("unknown error, attempting to continue\n");
        break;
    }
  }

  /* cleanup curl stuff */
  if (!ftp_keepalive) {
    curl_easy_cleanup(curl_handle);
    connections--;
    curl_slist_free_all(post_commands);
    post_commands = NULL;
  }
  fclose(infile);
}

int
check_interface(char *watch_interface)
{
  if (watch_interface == NULL)
    return 1;
  return if_nametoindex(watch_interface);
}

void
version(void)
{
  printf("camE version %s\n", VERSION);
  exit(0);
}

void
usage(void)
{
  printf("usage: camE [OPTION]\n");
  printf("       -c FILE    Use config file FILE\n");
  printf("       -f         Don't fork to background\n");
  printf("       -d         Detach after forking\n");
  printf("       -s         Single shot\n");
  printf("       -h -v      This message\n");
  exit(0);
}

int
do_upload(char *file)
{
  struct stat st;
  int upload_successful = 1;
  static int shot_counter = 0;

  shot_counter++;

  if (ftp_do && (shot_counter >= ftp_upload_every)) {
    if ((upload_blockfile && (stat(upload_blockfile, &st) == -1))
        || !upload_blockfile) {
      camlog("*** uploading via ftp\n");
      ftp_upload(file, ftp_file, ftp_tmp);
      camlog("shot uploaded\n");
      if (action_post_upload) {
        camlog("running post upload action\n");
        system(action_post_upload);
        camlog("post upload action done\n");
      }
    }
    shot_counter = 0;
  } else if (scp_target && (shot_counter >= ftp_upload_every)) {
    char target_buf[2048];
    char cmd_buf[4096];
    char *scp_args[] = { "scp", "-BCq", NULL, NULL, NULL };
    char *ssh_args[] = { "ssh", "-n", "-q", NULL, NULL, NULL };

    if (!upload_blockfile
        || (upload_blockfile && (stat(upload_blockfile, &st) == -1))) {
      camlog("uploading via scp\n");
      snprintf(target_buf, sizeof(target_buf), "%s:%s/%s", scp_target,
               ftp_dir, ftp_tmp);
      snprintf(cmd_buf, sizeof(cmd_buf), "mv %s/%s %s/%s", ftp_dir, ftp_tmp,
               ftp_dir, ftp_file);
      scp_args[2] = file;
      scp_args[3] = target_buf;
      if ((upload_successful =
           execvp_with_timeout(scp_timeout, "scp", scp_args))) {
        ssh_args[3] = scp_target;
        ssh_args[4] = cmd_buf;
        if ((upload_successful =
             execvp_with_timeout(scp_timeout, "ssh", ssh_args))) {
          camlog("shot uploaded\n");

          if (action_post_upload) {
            camlog("running post upload action\n");
            system(action_post_upload);
            camlog("post upload action done\n");
          }
        }
      }
    }
    shot_counter = 0;
  }
  return upload_successful;
}

int
main(int argc,
     char *argv[])
{
  unsigned char *val;
  Imlib_Image image, tmp_image;
  char filename[100];
  int width, height, i;
  struct stat st;
  pid_t childpid;
  float f;
  struct timeval start_shot;
  struct timeval end_shot;
  struct timeval new_delay;
  int just_shot = 0, upload_successful = 1;
  FILE *fp;
  int ch;
  int dont_fork = 0;
  int single_shot = 0;
  int offline_done = 1;
  char *config_file = NULL;
  int detach = 0;
  int ret;

  while ((ch = getopt(argc, argv, "c:fsdhv")) != EOF) {
    switch (ch) {
      case 'c':
        config_file = strdup(optarg);
        break;
      case 'f':
        if (detach) {
          fprintf(stderr, "-f does not make sense with -d specified.\n");
          exit(1);
        }
        dont_fork = 1;
        break;
      case 'd':
        if (dont_fork) {
          fprintf(stderr, "-d does not make sense with -f specified.\n");
          exit(1);
        }
        detach = 1;
        break;
      case 's':
        single_shot = 1;
        break;
      case 'h':
        usage();
        break;
      case 'v':
        version();
        break;
      case '?':
      default:
        usage();
        break;
    }
  }

  if (!dont_fork && !single_shot) {
    /* fork and die */
    if (detach) {
      ret = daemon(1,0);
      if (ret != 0)
	fprintf(stderr, "daemon (%s)\n", strerror(errno));
    } else if ((childpid = fork()) < 0) {
      fprintf(stderr, "fork (%s)\n", strerror(errno));