release 016
[gregoa/bti.git] / bti.c
diff --git a/bti.c b/bti.c
index 8243ad7..5f4a6cb 100644 (file)
--- a/bti.c
+++ b/bti.c
@@ -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"
 
 
@@ -55,7 +59,8 @@ enum action {
        ACTION_FRIENDS = 1,
        ACTION_USER = 2,
        ACTION_REPLIES = 4,
-       ACTION_PUBLIC = 8
+       ACTION_PUBLIC = 8,
+       ACTION_UNKNOWN = 16
 };
 
 struct session {
@@ -68,6 +73,8 @@ struct session {
        char *logfile;
        char *user;
        int bash;
+       int shrink_urls;
+       int dry_run;
        enum host host;
        enum action action;
 };
@@ -93,6 +100,7 @@ static void display_help(void)
        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");
@@ -383,6 +391,8 @@ static int send_request(struct session *session)
                        break;
                }
 
+               break;
+       default:
                break;
        }
 
@@ -398,10 +408,12 @@ static int send_request(struct session *session)
 
        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);
@@ -424,6 +436,7 @@ static void parse_configfile(struct session *session)
        char *action = NULL;
        char *user = NULL;
        char *file;
+       int shrink_urls = 0;
 
        /* config file is ~/.bti  */
        file = alloca(strlen(session->homedir) + 7);
@@ -489,6 +502,12 @@ static void parse_configfile(struct session *session)
                        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));
 
@@ -513,19 +532,22 @@ static void parse_configfile(struct session *session)
        if (action) {
                if (strcasecmp(action, "update") == 0)
                        session->action = ACTION_UPDATE;
-               if (strcasecmp(action, "friends") == 0)
+               else if (strcasecmp(action, "friends") == 0)
                        session->action = ACTION_FRIENDS;
-               if (strcasecmp(action, "user") == 0)
+               else if (strcasecmp(action, "user") == 0)
                        session->action = ACTION_USER;
-               if (strcasecmp(action, "replies") == 0)
+               else if (strcasecmp(action, "replies") == 0)
                        session->action = ACTION_REPLIES;
-               if (strcasecmp(action, "public") == 0)
+               else if (strcasecmp(action, "public") == 0)
                        session->action = ACTION_PUBLIC;
+               else
+                       session->action = ACTION_UNKNOWN;
                free(action);
        }
        if (user) {
                session->user = user;
        }
+       session->shrink_urls = shrink_urls;
 
        /* Free buffer and close file.  */
        free(line);
@@ -587,11 +609,282 @@ static void log_session(struct session *session, int retval)
                fprintf(log_file, "%s: host=%s retrieving public timeline\n",
                        session->time, host);
                break;
+       default:
+               break;
        }
 
        fclose(log_file);
 }
 
+static char *get_string_from_stdin(void)
+{
+       char *temp;
+       char *string;
+
+       string = zalloc(1000);
+       if (!string)
+               return NULL;
+
+       if (!fgets(string, 999, stdin))
+               return NULL;
+       temp = strchr(string, '\n');
+       *temp = '\0';
+       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);
+
+       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[] = {
@@ -603,8 +896,10 @@ int main(int argc, char *argv[], char *envp[])
                { "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' },
                { "version", 0, NULL, 'v' },
                { }
        };
@@ -676,14 +971,16 @@ int main(int argc, char *argv[], char *envp[])
                case 'A':
                        if (strcasecmp(optarg, "update") == 0)
                                session->action = ACTION_UPDATE;
-                       if (strcasecmp(optarg, "friends") == 0)
+                       else if (strcasecmp(optarg, "friends") == 0)
                                session->action = ACTION_FRIENDS;
-                       if (strcasecmp(optarg, "user") == 0)
+                       else if (strcasecmp(optarg, "user") == 0)
                                session->action = ACTION_USER;
-                       if (strcasecmp(optarg, "replies") == 0)
+                       else if (strcasecmp(optarg, "replies") == 0)
                                session->action = ACTION_REPLIES;
-                       if (strcasecmp(optarg, "public") == 0)
+                       else if (strcasecmp(optarg, "public") == 0)
                                session->action = ACTION_PUBLIC;
+                       else
+                               session->action = ACTION_UNKNOWN;
                        dbg("action = %d\n", session->action);
                        break;
                case 'u':
@@ -698,6 +995,9 @@ int main(int argc, char *argv[], char *envp[])
                        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;
@@ -711,6 +1011,9 @@ int main(int argc, char *argv[], char *envp[])
                case 'h':
                        display_help();
                        goto exit;
+               case 'n':
+                       session->dry_run = 1;
+                       break;
                case 'v':
                        display_version();
                        goto exit;
@@ -720,6 +1023,12 @@ int main(int argc, char *argv[], char *envp[])
                }
        }
 
+       if (session->action == ACTION_UNKNOWN) {
+               fprintf(stderr, "Unknown action, valid actions are:\n");
+               fprintf(stderr, "'update', 'friends', 'public', 'replies' or 'user'.\n");
+               goto exit;
+       }
+
        if (!session->account) {
                fprintf(stdout, "Enter twitter account: ");
                session->account = readline(NULL);
@@ -732,7 +1041,7 @@ int main(int argc, char *argv[], char *envp[])
 
        if (session->action == ACTION_UPDATE) {
                if (session->bash)
-                       tweet = readline(NULL);
+                       tweet = get_string_from_stdin();
                else
                        tweet = readline("tweet: ");
                if (!tweet || strlen(tweet) == 0) {
@@ -740,6 +1049,9 @@ int main(int argc, char *argv[], char *envp[])
                        return -1;
                }
 
+               if (session->shrink_urls)
+                       tweet = shrink_urls(tweet);
+
                session->tweet = zalloc(strlen(tweet) + 10);
                if (session->bash)
                        sprintf(session->tweet, "$ %s", tweet);
@@ -751,7 +1063,7 @@ int main(int argc, char *argv[], char *envp[])
        }
 
        if (!session->user)
-               session->user = session->account;
+               session->user = strdup(session->account);
 
        dbg("account = %s\n", session->account);
        dbg("password = %s\n", session->password);