Merge branch 'master' of git://github.com/psykoyiko/bti
authorGreg Kroah-Hartman <gregkh@suse.de>
Tue, 24 Mar 2009 04:52:37 +0000 (21:52 -0700)
committerGreg Kroah-Hartman <gregkh@suse.de>
Tue, 24 Mar 2009 04:52:37 +0000 (21:52 -0700)
1  2 
bti.c

diff --combined bti.c
--- 1/bti.c
--- 2/bti.c
+++ b/bti.c
@@@ -1,6 -1,5 +1,6 @@@
  /*
   * Copyright (C) 2008 Greg Kroah-Hartman <greg@kroah.com>
 + * Copyright (C) 2009 Bart Trojanowski <bart@jukie.net>
   *
   * This program is free software; you can redistribute it and/or modify it
   * under the terms of the GNU General Public License as published by the
  #include <unistd.h>
  #include <time.h>
  #include <sys/stat.h>
 +#include <sys/types.h>
 +#include <sys/wait.h>
  #include <curl/curl.h>
  #include <readline/readline.h>
  #include <libxml/xmlmemory.h>
  #include <libxml/parser.h>
  #include <libxml/tree.h>
 +#include <pcre.h>
  #include "bti_version.h"
  
  
@@@ -73,8 -69,7 +73,9 @@@ struct session 
        char *logfile;
        char *user;
        int bash;
 +      int shrink_urls;
 +      int dry_run;
+       int page;
        enum host host;
        enum action action;
  };
@@@ -95,13 -90,11 +96,13 @@@ static void display_help(void
        fprintf(stdout, "  --account accountname\n");
        fprintf(stdout, "  --password password\n");
        fprintf(stdout, "  --action action\n");
 -      fprintf(stdout, "    ('update', 'friends', 'public', 'replies' or 'user')\n");
 +      fprintf(stdout, "    ('update', 'friends', 'public', 'replies' "
 +              "or 'user')\n");
        fprintf(stdout, "  --user screenname\n");
        fprintf(stdout, "  --proxy PROXY:PORT\n");
        fprintf(stdout, "  --host HOST\n");
        fprintf(stdout, "  --logfile logfile\n");
 +      fprintf(stdout, "  --shrink-urls\n");
        fprintf(stdout, "  --bash\n");
        fprintf(stdout, "  --debug\n");
        fprintf(stdout, "  --version\n");
@@@ -232,9 -225,8 +233,9 @@@ static void parse_timeline(char *docume
  {
        xmlDocPtr doc;
        xmlNodePtr current;
 -      doc = xmlReadMemory(document, strlen(document), "timeline.xml", NULL, XML_PARSE_NOERROR);
  
 +      doc = xmlReadMemory(document, strlen(document), "timeline.xml",
 +                          NULL, XML_PARSE_NOERROR);
        if (doc == NULL)
                return;
  
@@@ -333,12 -325,10 +334,12 @@@ static int send_request(struct session 
                curl_easy_setopt(curl, CURLOPT_HTTPHEADER, slist);
                switch (session->host) {
                case HOST_TWITTER:
 -                      curl_easy_setopt(curl, CURLOPT_URL, twitter_update_url);
 +                      curl_easy_setopt(curl, CURLOPT_URL,
 +                                       twitter_update_url);
                        break;
                case HOST_IDENTICA:
 -                      curl_easy_setopt(curl, CURLOPT_URL, identica_update_url);
 +                      curl_easy_setopt(curl, CURLOPT_URL,
 +                                       identica_update_url);
                        break;
                }
                curl_easy_setopt(curl, CURLOPT_USERPWD, user_password);
                         session->account, session->password);
                switch (session->host) {
                case HOST_TWITTER:
-                       curl_easy_setopt(curl, CURLOPT_URL,
-                                        twitter_friends_url);
+                       sprintf(user_url, "%s?page=%d", twitter_friends_url, session->page);
+                       curl_easy_setopt(curl, CURLOPT_URL, user_url);
                        break;
                case HOST_IDENTICA:
-                       curl_easy_setopt(curl, CURLOPT_URL,
-                                        identica_friends_url);
+                       sprintf(user_url, "%s?page=%d", identica_friends_url, session->page);
+                       curl_easy_setopt(curl, CURLOPT_URL, user_url);
                        break;
                }
                curl_easy_setopt(curl, CURLOPT_USERPWD, user_password);
        case ACTION_USER:
                switch (session->host) {
                case HOST_TWITTER:
-                       sprintf(user_url, "%s%s.xml", twitter_user_url,
-                               session->user);
+                       sprintf(user_url, "%s%s.xml?page=%d", twitter_user_url, session->user, session->page);
                        curl_easy_setopt(curl, CURLOPT_URL, user_url);
                        break;
                case HOST_IDENTICA:
-                       sprintf(user_url, "%s%s.xml", identica_user_url,
-                               session->user);
+                       sprintf(user_url, "%s%s.xml?page=%d", identica_user_url, session->user, session->page);
                        curl_easy_setopt(curl, CURLOPT_URL, user_url);
                        break;
                }
                         session->account, session->password);
                switch (session->host) {
                case HOST_TWITTER:
-                       curl_easy_setopt(curl, CURLOPT_URL,
-                                        twitter_replies_url);
+                       sprintf(user_url, "%s?page=%d", twitter_replies_url, session->page);
+                       curl_easy_setopt(curl, CURLOPT_URL, user_url);
                        break;
                case HOST_IDENTICA:
-                       curl_easy_setopt(curl, CURLOPT_URL,
-                                        identica_replies_url);
+                       sprintf(user_url, "%s?page=%d", identica_replies_url, session->page);
+                       curl_easy_setopt(curl, CURLOPT_URL, user_url);
                        break;
                }
                curl_easy_setopt(curl, CURLOPT_USERPWD, user_password);
        case ACTION_PUBLIC:
                switch (session->host) {
                case HOST_TWITTER:
-                       curl_easy_setopt(curl, CURLOPT_URL,
-                                        twitter_public_url);
+                       sprintf(user_url, "%s?page=%d", twitter_public_url, session->page);
+                       curl_easy_setopt(curl, CURLOPT_URL, user_url);
                        break;
                case HOST_IDENTICA:
-                       curl_easy_setopt(curl, CURLOPT_URL,
-                                        identica_public_url);
+                       sprintf(user_url, "%s?page=%d", identica_public_url, session->page);
+                       curl_easy_setopt(curl, CURLOPT_URL, user_url);
                        break;
                }
  
  
        curl_easy_setopt(curl, CURLOPT_WRITEFUNCTION, curl_callback);
        curl_easy_setopt(curl, CURLOPT_WRITEDATA, curl_buf);
 -      res = curl_easy_perform(curl);
 -      if (res && !session->bash) {
 -              fprintf(stderr, "error(%d) trying to perform operation\n", res);
 -              return -EINVAL;
 +      if (!session->dry_run) {
 +              res = curl_easy_perform(curl);
 +              if (res && !session->bash) {
 +                      fprintf(stderr, "error(%d) trying to perform "
 +                              "operation\n", res);
 +                      return -EINVAL;
 +              }
        }
  
        curl_easy_cleanup(curl);
@@@ -449,7 -434,6 +448,7 @@@ static void parse_configfile(struct ses
        char *action = NULL;
        char *user = NULL;
        char *file;
 +      int shrink_urls = 0;
  
        /* config file is ~/.bti  */
        file = alloca(strlen(session->homedir) + 7);
                        c += 5;
                        if (c[0] != '\0')
                                user = strdup(c);
 +              } else if (!strncasecmp(c, "shrink-urls", 11) &&
 +                              (c[11] == '=')) {
 +                      c += 12;
 +                      if (!strncasecmp(c, "true", 4) ||
 +                                      !strncasecmp(c, "yes", 3))
 +                              shrink_urls = 1;
                }
        } while (!feof(config_file));
  
                        session->action = ACTION_UNKNOWN;
                free(action);
        }
 -      if (user) {
 +      if (user)
                session->user = user;
 -      }
 +      session->shrink_urls = shrink_urls;
  
        /* Free buffer and close file.  */
        free(line);
@@@ -644,268 -622,6 +643,268 @@@ static char *get_string_from_stdin(void
        return string;
  }
  
 +static int find_urls(const char *tweet, int **pranges)
 +{
 +      /*
 +       * magic obtained from
 +       * http://www.geekpedia.com/KB65_How-to-validate-an-URL-using-RegEx-in-Csharp.html
 +       */
 +      static const char *re_magic =
 +              "(([a-zA-Z][0-9a-zA-Z+\\-\\.]*:)/{1,3}"
 +              "[0-9a-zA-Z;/~?:@&=+$\\.\\-_'()%]+)"
 +              "(#[0-9a-zA-Z;/?:@&=+$\\.\\-_!~*'()%]+)?";
 +      pcre *re;
 +      const char *errptr;
 +      int erroffset;
 +      int ovector[10] = {0,};
 +      const size_t ovsize = sizeof(ovector)/sizeof(*ovector);
 +      int startoffset, tweetlen;
 +      int i, rc;
 +      int rbound = 10;
 +      int rcount = 0;
 +      int *ranges = malloc(sizeof(int) * rbound);
 +
 +      re = pcre_compile(re_magic,
 +                      PCRE_NO_AUTO_CAPTURE,
 +                      &errptr, &erroffset, NULL);
 +      if (!re) {
 +              fprintf(stderr, "pcre_compile @%u: %s\n", erroffset, errptr);
 +              exit(1);
 +      }
 +
 +      tweetlen = strlen(tweet);
 +      for (startoffset = 0; startoffset < tweetlen; ) {
 +
 +              rc = pcre_exec(re, NULL, tweet, strlen(tweet), startoffset, 0,
 +                              ovector, ovsize);
 +              if (rc == PCRE_ERROR_NOMATCH)
 +                      break;
 +
 +              if (rc < 0) {
 +                      fprintf(stderr, "pcre_exec @%u: %s\n",
 +                              erroffset, errptr);
 +                      exit(1);
 +              }
 +
 +              for (i = 0; i < rc; i += 2) {
 +                      if ((rcount+2) == rbound) {
 +                              rbound *= 2;
 +                              ranges = realloc(ranges, sizeof(int) * rbound);
 +                      }
 +
 +                      ranges[rcount++] = ovector[i];
 +                      ranges[rcount++] = ovector[i+1];
 +              }
 +
 +              startoffset = ovector[1];
 +      }
 +
 +      pcre_free(re);
 +
 +      *pranges = ranges;
 +      return rcount;
 +}
 +
 +/**
 + * bidirectional popen() call
 + *
 + * @param rwepipe - int array of size three
 + * @param exe - program to run
 + * @param argv - argument list
 + * @return pid or -1 on error
 + *
 + * The caller passes in an array of three integers (rwepipe), on successful
 + * execution it can then write to element 0 (stdin of exe), and read from
 + * element 1 (stdout) and 2 (stderr).
 + */
 +static int popenRWE(int *rwepipe, const char *exe, const char *const argv[])
 +{
 +      int in[2];
 +      int out[2];
 +      int err[2];
 +      int pid;
 +      int rc;
 +
 +      rc = pipe(in);
 +      if (rc < 0)
 +              goto error_in;
 +
 +      rc = pipe(out);
 +      if (rc < 0)
 +              goto error_out;
 +
 +      rc = pipe(err);
 +      if (rc < 0)
 +              goto error_err;
 +
 +      pid = fork();
 +      if (pid > 0) {
 +              /* parent */
 +              close(in[0]);
 +              close(out[1]);
 +              close(err[1]);
 +              rwepipe[0] = in[1];
 +              rwepipe[1] = out[0];
 +              rwepipe[2] = err[0];
 +              return pid;
 +      } else if (pid == 0) {
 +              /* child */
 +              close(in[1]);
 +              close(out[0]);
 +              close(err[0]);
 +              close(0);
 +              rc = dup(in[0]);
 +              close(1);
 +              rc = dup(out[1]);
 +              close(2);
 +              rc = dup(err[1]);
 +
 +              execvp(exe, (char **)argv);
 +              exit(1);
 +      } else
 +              goto error_fork;
 +
 +      return pid;
 +
 +error_fork:
 +      close(err[0]);
 +      close(err[1]);
 +error_err:
 +      close(out[0]);
 +      close(out[1]);
 +error_out:
 +      close(in[0]);
 +      close(in[1]);
 +error_in:
 +      return -1;
 +}
 +
 +static int pcloseRWE(int pid, int *rwepipe)
 +{
 +      int rc, status;
 +      close(rwepipe[0]);
 +      close(rwepipe[1]);
 +      close(rwepipe[2]);
 +      rc = waitpid(pid, &status, 0);
 +      return status;
 +}
 +
 +static char *shrink_one_url(int *rwepipe, char *big)
 +{
 +      int biglen = strlen(big);
 +      char *small;
 +      int smalllen;
 +      int rc;
 +
 +      rc = dprintf(rwepipe[0], "%s\n", big);
 +      if (rc < 0)
 +              return big;
 +
 +      smalllen = biglen + 128;
 +      small = malloc(smalllen);
 +      if (!small)
 +              return big;
 +
 +      rc = read(rwepipe[1], small, smalllen);
 +      if (rc < 0 || rc > biglen)
 +              goto error_free_small;
 +
 +      if (strncmp(small, "http://", 7))
 +              goto error_free_small;
 +
 +      smalllen = rc;
 +      while (smalllen && isspace(small[smalllen-1]))
 +                      small[--smalllen] = 0;
 +
 +      free(big);
 +      return small;
 +
 +error_free_small:
 +      free(small);
 +      return big;
 +}
 +
 +static char *shrink_urls(char *text)
 +{
 +      int *ranges;
 +      int rcount;
 +      int i;
 +      int inofs = 0;
 +      int outofs = 0;
 +      const char *const shrink_args[] = {
 +              "bti-shrink-urls",
 +              NULL
 +      };
 +      int shrink_pid;
 +      int shrink_pipe[3];
 +      int inlen = strlen(text);
 +
 +      dbg("before len=%u\n", inlen);
 +
 +      shrink_pid = popenRWE(shrink_pipe, shrink_args[0], shrink_args);
 +      if (shrink_pid < 0)
 +              return text;
 +
 +      rcount = find_urls(text, &ranges);
 +      if (!rcount)
 +              return text;
 +
 +      for (i = 0; i < rcount; i += 2) {
 +              int url_start = ranges[i];
 +              int url_end = ranges[i+1];
 +              int long_url_len = url_end - url_start;
 +              char *url = strndup(text + url_start, long_url_len);
 +              int short_url_len;
 +              int not_url_len = url_start - inofs;
 +
 +              dbg("long  url[%u]: %s\n", long_url_len, url);
 +              url = shrink_one_url(shrink_pipe, url);
 +              short_url_len = url ? strlen(url) : 0;
 +              dbg("short url[%u]: %s\n", short_url_len, url);
 +
 +              if (!url || short_url_len >= long_url_len) {
 +                      /* The short url ended up being too long
 +                       * or unavailable */
 +                      if (inofs) {
 +                              strncpy(text + outofs, text + inofs,
 +                                              not_url_len + long_url_len);
 +                      }
 +                      inofs += not_url_len + long_url_len;
 +                      outofs += not_url_len + long_url_len;
 +
 +              } else {
 +                      /* copy the unmodified block */
 +                      strncpy(text + outofs, text + inofs, not_url_len);
 +                      inofs += not_url_len;
 +                      outofs += not_url_len;
 +
 +                      /* copy the new url */
 +                      strncpy(text + outofs, url, short_url_len);
 +                      inofs += long_url_len;
 +                      outofs += short_url_len;
 +              }
 +
 +              free(url);
 +      }
 +
 +      /* copy the last block after the last match */
 +      if (inofs) {
 +              int tail = inlen - inofs;
 +              if (tail) {
 +                      strncpy(text + outofs, text + inofs, tail);
 +                      outofs += tail;
 +              }
 +      }
 +
 +      free(ranges);
 +
 +      (void)pcloseRWE(shrink_pid, shrink_pipe);
 +
 +      text[outofs] = 0;
 +      dbg("after len=%u\n", outofs);
 +      return text;
 +}
 +
  int main(int argc, char *argv[], char *envp[])
  {
        static const struct option options[] = {
                { "action", 1, NULL, 'A' },
                { "user", 1, NULL, 'u' },
                { "logfile", 1, NULL, 'L' },
 +              { "shrink-urls", 0, NULL, 's' },
                { "help", 0, NULL, 'h' },
                { "bash", 0, NULL, 'b' },
 +              { "dry-run", 0, NULL, 'n' },
+               { "page", 1, NULL, 'g' },
                { "version", 0, NULL, 'v' },
                { }
        };
        int option;
        char *http_proxy;
        time_t t;
+       int page_nr;
  
        debug = 0;
        rl_bind_key('\t', rl_insert);
        parse_configfile(session);
  
        while (1) {
-               option = getopt_long_only(argc, argv, "dqe:p:P:H:a:A:u:h",
+               option = getopt_long_only(argc, argv, "dqe:p:P:H:a:A:u:hg:",
                                          options, NULL);
                if (option == -1)
                        break;
                        session->account = strdup(optarg);
                        dbg("account = %s\n", session->account);
                        break;
+               case 'g':
+                       page_nr = atoi(optarg);
+                       dbg("page = %d\n", page_nr);
+                       session->page = page_nr;
+                       break;
                case 'p':
                        if (session->password)
                                free(session->password);
                        session->logfile = strdup(optarg);
                        dbg("logfile = %s\n", session->logfile);
                        break;
 +              case 's':
 +                      session->shrink_urls = 1;
 +                      break;
                case 'H':
                        if (strcasecmp(optarg, "twitter") == 0)
                                session->host = HOST_TWITTER;
                case 'h':
                        display_help();
                        goto exit;
 +              case 'n':
 +                      session->dry_run = 1;
 +                      break;
                case 'v':
                        display_version();
                        goto exit;
  
        if (session->action == ACTION_UNKNOWN) {
                fprintf(stderr, "Unknown action, valid actions are:\n");
 -              fprintf(stderr, "'update', 'friends', 'public', 'replies' or 'user'.\n");
 +              fprintf(stderr, "'update', 'friends', 'public', "
 +                      "'replies' or 'user'.\n");
                goto exit;
        }
  
                        return -1;
                }
  
 +              if (session->shrink_urls)
 +                      tweet = shrink_urls(tweet);
 +
                session->tweet = zalloc(strlen(tweet) + 10);
                if (session->bash)
                        sprintf(session->tweet, "$ %s", tweet);
        if (!session->user)
                session->user = strdup(session->account);
  
+       if (session->page == 0)
+               session->page = 1;
        dbg("account = %s\n", session->account);
        dbg("password = %s\n", session->password);
        dbg("host = %d\n", session->host);