/[debian]/bti/branches/upstream/current/bti.c
ViewVC logotype

Contents of /bti/branches/upstream/current/bti.c

Parent Directory Parent Directory | Revision Log Revision Log


Revision 2449 - (show annotations)
Fri Mar 18 11:13:50 2011 UTC (9 years, 7 months ago) by gregoa
File MIME type: text/plain
File size: 35512 byte(s)
[svn-upgrade] new version bti (030)
1 /*
2 * Copyright (C) 2008-2011 Greg Kroah-Hartman <greg@kroah.com>
3 * Copyright (C) 2009 Bart Trojanowski <bart@jukie.net>
4 * Copyright (C) 2009-2010 Amir Mohammad Saied <amirsaied@gmail.com>
5 *
6 * This program is free software; you can redistribute it and/or modify it
7 * under the terms of the GNU General Public License as published by the
8 * Free Software Foundation version 2 of the License.
9 *
10 * This program is distributed in the hope that it will be useful, but
11 * WITHOUT ANY WARRANTY; without even the implied warranty of
12 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
13 * General Public License for more details.
14 *
15 * You should have received a copy of the GNU General Public License along
16 * with this program; if not, write to the Free Software Foundation, Inc.,
17 * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
18 */
19
20 #define _GNU_SOURCE
21
22 #include <stdio.h>
23 #include <stdlib.h>
24 #include <stddef.h>
25 #include <string.h>
26 #include <getopt.h>
27 #include <errno.h>
28 #include <ctype.h>
29 #include <fcntl.h>
30 #include <unistd.h>
31 #include <time.h>
32 #include <sys/stat.h>
33 #include <sys/types.h>
34 #include <sys/wait.h>
35 #include <curl/curl.h>
36 #include <libxml/xmlmemory.h>
37 #include <libxml/parser.h>
38 #include <libxml/tree.h>
39 #include <pcre.h>
40 #include <termios.h>
41 #include <dlfcn.h>
42 #include <oauth.h>
43 #include "bti.h"
44
45 #define zalloc(size) calloc(size, 1)
46
47 #define dbg(format, arg...) \
48 do { \
49 if (debug) \
50 fprintf(stdout, "bti: %s: " format , __func__ , \
51 ## arg); \
52 } while (0)
53
54
55 int debug;
56
57 static void display_help(void)
58 {
59 fprintf(stdout, "bti - send tweet to twitter or identi.ca\n"
60 "Version: %s\n"
61 "Usage:\n"
62 " bti [options]\n"
63 "options are:\n"
64 " --account accountname\n"
65 " --password password\n"
66 " --action action\n"
67 " ('update', 'friends', 'public', 'replies', or 'user')\n"
68 " --user screenname\n"
69 " --group groupname\n"
70 " --proxy PROXY:PORT\n"
71 " --host HOST\n"
72 " --logfile logfile\n"
73 " --config configfile\n"
74 " --replyto ID\n"
75 " --retweet ID\n"
76 " --shrink-urls\n"
77 " --page PAGENUMBER\n"
78 " --bash\n"
79 " --background\n"
80 " --debug\n"
81 " --verbose\n"
82 " --dry-run\n"
83 " --version\n"
84 " --help\n", VERSION);
85 }
86
87 static void display_version(void)
88 {
89 fprintf(stdout, "bti - version %s\n", VERSION);
90 }
91
92 static char *get_string(const char *name)
93 {
94 char *temp;
95 char *string;
96
97 string = zalloc(1000);
98 if (!string)
99 exit(1);
100 if (name != NULL)
101 fprintf(stdout, "%s", name);
102 if (!fgets(string, 999, stdin))
103 return NULL;
104 temp = strchr(string, '\n');
105 if (temp)
106 *temp = '\0';
107 return string;
108 }
109
110 /*
111 * Try to get a handle to a readline function from a variety of different
112 * libraries. If nothing is present on the system, then fall back to an
113 * internal one.
114 *
115 * Logic originally based off of code in the e2fsutils package in the
116 * lib/ss/get_readline.c file, which is licensed under the MIT license.
117 *
118 * This keeps us from having to relicense the bti codebase if readline
119 * ever changes its license, as there is no link-time dependancy.
120 * It is a run-time thing only, and we handle any readline-like library
121 * in the same manner, making bti not be a derivative work of any
122 * other program.
123 */
124 static void session_readline_init(struct session *session)
125 {
126 /* Libraries we will try to use for readline/editline functionality */
127 const char *libpath = "libreadline.so.6:libreadline.so.5:"
128 "libreadline.so.4:libreadline.so:libedit.so.2:"
129 "libedit.so:libeditline.so.0:libeditline.so";
130 void *handle = NULL;
131 char *tmp, *cp, *next;
132 int (*bind_key)(int, void *);
133 void (*insert)(void);
134
135 /* default to internal function if we can't or won't find anything */
136 session->readline = get_string;
137 if (!isatty(0))
138 return;
139 session->interactive = 1;
140
141 tmp = malloc(strlen(libpath)+1);
142 if (!tmp)
143 return;
144 strcpy(tmp, libpath);
145 for (cp = tmp; cp; cp = next) {
146 next = strchr(cp, ':');
147 if (next)
148 *next++ = 0;
149 if (*cp == 0)
150 continue;
151 handle = dlopen(cp, RTLD_NOW);
152 if (handle) {
153 dbg("Using %s for readline library\n", cp);
154 break;
155 }
156 }
157 free(tmp);
158 if (!handle) {
159 dbg("No readline library found.\n");
160 return;
161 }
162
163 session->readline_handle = handle;
164 session->readline = (char *(*)(const char *))dlsym(handle, "readline");
165 if (session->readline == NULL) {
166 /* something odd happened, default back to internal stuff */
167 session->readline_handle = NULL;
168 session->readline = get_string;
169 return;
170 }
171
172 /*
173 * If we found a library, turn off filename expansion
174 * as that makes no sense from within bti.
175 */
176 bind_key = (int (*)(int, void *))dlsym(handle, "rl_bind_key");
177 insert = (void (*)(void))dlsym(handle, "rl_insert");
178 if (bind_key && insert)
179 bind_key('\t', insert);
180 }
181
182 static void session_readline_cleanup(struct session *session)
183 {
184 if (session->readline_handle)
185 dlclose(session->readline_handle);
186 }
187
188 static struct session *session_alloc(void)
189 {
190 struct session *session;
191
192 session = zalloc(sizeof(*session));
193 if (!session)
194 return NULL;
195 return session;
196 }
197
198 static void session_free(struct session *session)
199 {
200 if (!session)
201 return;
202 free(session->retweet);
203 free(session->replyto);
204 free(session->password);
205 free(session->account);
206 free(session->consumer_key);
207 free(session->consumer_secret);
208 free(session->access_token_key);
209 free(session->access_token_secret);
210 free(session->tweet);
211 free(session->proxy);
212 free(session->time);
213 free(session->homedir);
214 free(session->user);
215 free(session->group);
216 free(session->hosturl);
217 free(session->hostname);
218 free(session->configfile);
219 free(session);
220 }
221
222 static struct bti_curl_buffer *bti_curl_buffer_alloc(enum action action)
223 {
224 struct bti_curl_buffer *buffer;
225
226 buffer = zalloc(sizeof(*buffer));
227 if (!buffer)
228 return NULL;
229
230 /* start out with a data buffer of 1 byte to
231 * make the buffer fill logic simpler */
232 buffer->data = zalloc(1);
233 if (!buffer->data) {
234 free(buffer);
235 return NULL;
236 }
237 buffer->length = 0;
238 buffer->action = action;
239 return buffer;
240 }
241
242 static void bti_curl_buffer_free(struct bti_curl_buffer *buffer)
243 {
244 if (!buffer)
245 return;
246 free(buffer->data);
247 free(buffer);
248 }
249
250 const char twitter_host[] = "http://api.twitter.com/1/statuses";
251 const char identica_host[] = "https://identi.ca/api/statuses";
252 const char twitter_name[] = "twitter";
253 const char identica_name[] = "identi.ca";
254
255 static const char twitter_request_token_uri[] = "http://twitter.com/oauth/request_token";
256 static const char twitter_access_token_uri[] = "http://twitter.com/oauth/access_token";
257 static const char twitter_authorize_uri[] = "http://twitter.com/oauth/authorize?oauth_token=";
258 static const char identica_request_token_uri[] = "http://identi.ca/api/oauth/request_token?oauth_callback=oob";
259 static const char identica_access_token_uri[] = "http://identi.ca/api/oauth/access_token";
260 static const char identica_authorize_uri[] = "http://identi.ca/api/oauth/authorize?oauth_token=";
261
262 static const char user_uri[] = "/user_timeline/";
263 static const char update_uri[] = "/update.xml";
264 static const char public_uri[] = "/public_timeline.xml";
265 static const char friends_uri[] = "/friends_timeline.xml";
266 static const char mentions_uri[] = "/mentions.xml";
267 static const char replies_uri[] = "/replies.xml";
268 static const char retweet_uri[] = "/retweet/";
269 static const char group_uri[] = "/../statusnet/groups/timeline/";
270
271 static CURL *curl_init(void)
272 {
273 CURL *curl;
274
275 curl = curl_easy_init();
276 if (!curl) {
277 fprintf(stderr, "Can not init CURL!\n");
278 return NULL;
279 }
280 /* some ssl sanity checks on the connection we are making */
281 curl_easy_setopt(curl, CURLOPT_SSL_VERIFYPEER, 0);
282 curl_easy_setopt(curl, CURLOPT_SSL_VERIFYHOST, 0);
283 return curl;
284 }
285
286 /* The final place data is sent to the screen/pty/tty */
287 static void bti_output_line(struct session *session, xmlChar *user,
288 xmlChar *id, xmlChar *created, xmlChar *text)
289 {
290 if (session->verbose)
291 printf("[%s] {%s} (%.16s) %s\n", user, id, created, text);
292 else
293 printf("[%s] %s\n", user, text);
294 }
295
296 static void parse_statuses(struct session *session,
297 xmlDocPtr doc, xmlNodePtr current)
298 {
299 xmlChar *text = NULL;
300 xmlChar *user = NULL;
301 xmlChar *created = NULL;
302 xmlChar *id = NULL;
303 xmlNodePtr userinfo;
304
305 current = current->xmlChildrenNode;
306 while (current != NULL) {
307 if (current->type == XML_ELEMENT_NODE) {
308 if (!xmlStrcmp(current->name, (const xmlChar *)"created_at"))
309 created = xmlNodeListGetString(doc, current->xmlChildrenNode, 1);
310 if (!xmlStrcmp(current->name, (const xmlChar *)"text"))
311 text = xmlNodeListGetString(doc, current->xmlChildrenNode, 1);
312 if (!xmlStrcmp(current->name, (const xmlChar *)"id"))
313 id = xmlNodeListGetString(doc, current->xmlChildrenNode, 1);
314 if (!xmlStrcmp(current->name, (const xmlChar *)"user")) {
315 userinfo = current->xmlChildrenNode;
316 while (userinfo != NULL) {
317 if ((!xmlStrcmp(userinfo->name, (const xmlChar *)"screen_name"))) {
318 if (user)
319 xmlFree(user);
320 user = xmlNodeListGetString(doc, userinfo->xmlChildrenNode, 1);
321 }
322 userinfo = userinfo->next;
323 }
324 }
325
326 if (user && text && created && id) {
327 bti_output_line(session, user, id, created, text);
328 xmlFree(user);
329 xmlFree(text);
330 xmlFree(created);
331 xmlFree(id);
332 user = NULL;
333 text = NULL;
334 created = NULL;
335 id = NULL;
336 }
337 }
338 current = current->next;
339 }
340
341 return;
342 }
343
344 static void parse_timeline(char *document, struct session *session)
345 {
346 xmlDocPtr doc;
347 xmlNodePtr current;
348
349 doc = xmlReadMemory(document, strlen(document), "timeline.xml",
350 NULL, XML_PARSE_NOERROR);
351 if (doc == NULL)
352 return;
353
354 current = xmlDocGetRootElement(doc);
355 if (current == NULL) {
356 fprintf(stderr, "empty document\n");
357 xmlFreeDoc(doc);
358 return;
359 }
360
361 if (xmlStrcmp(current->name, (const xmlChar *) "statuses")) {
362 fprintf(stderr, "unexpected document type\n");
363 xmlFreeDoc(doc);
364 return;
365 }
366
367 current = current->xmlChildrenNode;
368 while (current != NULL) {
369 if ((!xmlStrcmp(current->name, (const xmlChar *)"status")))
370 parse_statuses(session, doc, current);
371 current = current->next;
372 }
373 xmlFreeDoc(doc);
374
375 return;
376 }
377
378 static size_t curl_callback(void *buffer, size_t size, size_t nmemb,
379 void *userp)
380 {
381 struct bti_curl_buffer *curl_buf = userp;
382 size_t buffer_size = size * nmemb;
383 char *temp;
384
385 if ((!buffer) || (!buffer_size) || (!curl_buf))
386 return -EINVAL;
387
388 /* add to the data we already have */
389 temp = zalloc(curl_buf->length + buffer_size + 1);
390 if (!temp)
391 return -ENOMEM;
392
393 memcpy(temp, curl_buf->data, curl_buf->length);
394 free(curl_buf->data);
395 curl_buf->data = temp;
396 memcpy(&curl_buf->data[curl_buf->length], (char *)buffer, buffer_size);
397 curl_buf->length += buffer_size;
398 if (curl_buf->action)
399 parse_timeline(curl_buf->data, curl_buf->session);
400
401 dbg("%s\n", curl_buf->data);
402
403 return buffer_size;
404 }
405
406 static int parse_osp_reply(const char *reply, char **token, char **secret)
407 {
408 int rc;
409 int retval = 1;
410 char **rv = NULL;
411 rc = oauth_split_url_parameters(reply, &rv);
412 qsort(rv, rc, sizeof(char *), oauth_cmpstringp);
413 if (rc == 2 || rc == 4) {
414 if (!strncmp(rv[0], "oauth_token=", 11) &&
415 !strncmp(rv[1], "oauth_token_secret=", 18)) {
416 if (token)
417 *token = strdup(&(rv[0][12]));
418 if (secret)
419 *secret = strdup(&(rv[1][19]));
420
421 retval = 0;
422 }
423 } else if (rc == 3) {
424 if (!strncmp(rv[1], "oauth_token=", 11) &&
425 !strncmp(rv[2], "oauth_token_secret=", 18)) {
426 if (token)
427 *token = strdup(&(rv[1][12]));
428 if (secret)
429 *secret = strdup(&(rv[2][19]));
430
431 retval = 0;
432 }
433 }
434
435 dbg("token: %s\n", *token);
436 dbg("secret: %s\n", *secret);
437
438 if (rv)
439 free(rv);
440
441 return retval;
442 }
443
444 static int request_access_token(struct session *session)
445 {
446 char *post_params = NULL;
447 char *request_url = NULL;
448 char *reply = NULL;
449 char *at_key = NULL;
450 char *at_secret = NULL;
451 char *verifier = NULL;
452 char at_uri[90];
453
454 if (!session)
455 return -EINVAL;
456
457 if (session->host == HOST_TWITTER)
458 request_url = oauth_sign_url2(
459 twitter_request_token_uri, NULL,
460 OA_HMAC, NULL, session->consumer_key,
461 session->consumer_secret, NULL, NULL);
462 else if (session->host == HOST_IDENTICA)
463 request_url = oauth_sign_url2(
464 identica_request_token_uri, NULL,
465 OA_HMAC, NULL, session->consumer_key,
466 session->consumer_secret, NULL, NULL);
467 reply = oauth_http_get(request_url, post_params);
468
469 if (request_url)
470 free(request_url);
471
472 if (post_params)
473 free(post_params);
474
475 if (!reply)
476 return 1;
477
478 if (parse_osp_reply(reply, &at_key, &at_secret))
479 return 1;
480
481 free(reply);
482
483 fprintf(stdout,
484 "Please open the following link in your browser, and "
485 "allow 'bti' to access your account. Then paste "
486 "back the provided PIN in here.\n");
487 if (session->host == HOST_TWITTER) {
488 fprintf(stdout, "%s%s\nPIN: ", twitter_authorize_uri, at_key);
489 verifier = session->readline(NULL);
490 sprintf(at_uri, "%s?oauth_verifier=%s",
491 twitter_access_token_uri, verifier);
492 } else if (session->host == HOST_IDENTICA) {
493 fprintf(stdout, "%s%s\nPIN: ", identica_authorize_uri, at_key);
494 verifier = session->readline(NULL);
495 sprintf(at_uri, "%s?oauth_verifier=%s",
496 identica_access_token_uri, verifier);
497 }
498 request_url = oauth_sign_url2(at_uri, NULL, OA_HMAC, NULL,
499 session->consumer_key,
500 session->consumer_secret,
501 at_key, at_secret);
502 reply = oauth_http_get(request_url, post_params);
503
504 if (!reply)
505 return 1;
506
507 if (parse_osp_reply(reply, &at_key, &at_secret))
508 return 1;
509
510 free(reply);
511
512 fprintf(stdout,
513 "Please put these two lines in your bti "
514 "configuration file (~/.bti):\n"
515 "access_token_key=%s\n"
516 "access_token_secret=%s\n",
517 at_key, at_secret);
518
519 return 0;
520 }
521
522 static int send_request(struct session *session)
523 {
524 char endpoint[500];
525 char user_password[500];
526 char data[500];
527 struct bti_curl_buffer *curl_buf;
528 CURL *curl = NULL;
529 CURLcode res;
530 struct curl_httppost *formpost = NULL;
531 struct curl_httppost *lastptr = NULL;
532 struct curl_slist *slist = NULL;
533 char *req_url = NULL;
534 char *reply = NULL;
535 char *postarg = NULL;
536 char *escaped_tweet = NULL;
537 int is_post = 0;
538
539 if (!session)
540 return -EINVAL;
541
542 if (!session->hosturl)
543 session->hosturl = strdup(twitter_host);
544
545 if (session->no_oauth || session->guest) {
546 curl_buf = bti_curl_buffer_alloc(session->action);
547 if (!curl_buf)
548 return -ENOMEM;
549 curl_buf->session = session;
550
551 curl = curl_init();
552 if (!curl)
553 return -EINVAL;
554
555 if (!session->hosturl)
556 session->hosturl = strdup(twitter_host);
557
558 switch (session->action) {
559 case ACTION_UPDATE:
560 snprintf(user_password, sizeof(user_password), "%s:%s",
561 session->account, session->password);
562 snprintf(data, sizeof(data), "status=\"%s\"",
563 session->tweet);
564 curl_formadd(&formpost, &lastptr,
565 CURLFORM_COPYNAME, "status",
566 CURLFORM_COPYCONTENTS, session->tweet,
567 CURLFORM_END);
568
569 curl_formadd(&formpost, &lastptr,
570 CURLFORM_COPYNAME, "source",
571 CURLFORM_COPYCONTENTS, "bti",
572 CURLFORM_END);
573
574 if (session->replyto)
575 curl_formadd(&formpost, &lastptr,
576 CURLFORM_COPYNAME, "in_reply_to_status_id",
577 CURLFORM_COPYCONTENTS, session->replyto,
578 CURLFORM_END);
579
580 curl_easy_setopt(curl, CURLOPT_HTTPPOST, formpost);
581 slist = curl_slist_append(slist, "Expect:");
582 curl_easy_setopt(curl, CURLOPT_HTTPHEADER, slist);
583
584 sprintf(endpoint, "%s%s", session->hosturl, update_uri);
585 curl_easy_setopt(curl, CURLOPT_URL, endpoint);
586 curl_easy_setopt(curl, CURLOPT_USERPWD, user_password);
587 break;
588
589 case ACTION_FRIENDS:
590 snprintf(user_password, sizeof(user_password), "%s:%s",
591 session->account, session->password);
592 sprintf(endpoint, "%s%s?page=%d", session->hosturl,
593 friends_uri, session->page);
594 curl_easy_setopt(curl, CURLOPT_URL, endpoint);
595 curl_easy_setopt(curl, CURLOPT_USERPWD, user_password);
596 break;
597
598 case ACTION_USER:
599 sprintf(endpoint, "%s%s%s.xml?page=%d", session->hosturl,
600 user_uri, session->user, session->page);
601 curl_easy_setopt(curl, CURLOPT_URL, endpoint);
602 break;
603
604 case ACTION_REPLIES:
605 snprintf(user_password, sizeof(user_password), "%s:%s",
606 session->account, session->password);
607 sprintf(endpoint, "%s%s?page=%d", session->hosturl,
608 replies_uri, session->page);
609 curl_easy_setopt(curl, CURLOPT_URL, endpoint);
610 curl_easy_setopt(curl, CURLOPT_USERPWD, user_password);
611 break;
612
613 case ACTION_PUBLIC:
614 sprintf(endpoint, "%s%s?page=%d", session->hosturl,
615 public_uri, session->page);
616 curl_easy_setopt(curl, CURLOPT_URL, endpoint);
617 break;
618
619 case ACTION_GROUP:
620 sprintf(endpoint, "%s%s%s.xml?page=%d",
621 session->hosturl, group_uri, session->group,
622 session->page);
623 curl_easy_setopt(curl, CURLOPT_URL, endpoint);
624 break;
625
626 default:
627 break;
628 }
629
630 if (session->proxy)
631 curl_easy_setopt(curl, CURLOPT_PROXY, session->proxy);
632
633 if (debug)
634 curl_easy_setopt(curl, CURLOPT_VERBOSE, 1);
635
636 dbg("user_password = %s\n", user_password);
637 dbg("data = %s\n", data);
638 dbg("proxy = %s\n", session->proxy);
639
640 curl_easy_setopt(curl, CURLOPT_WRITEFUNCTION, curl_callback);
641 curl_easy_setopt(curl, CURLOPT_WRITEDATA, curl_buf);
642 if (!session->dry_run) {
643 res = curl_easy_perform(curl);
644 if (res && !session->background) {
645 fprintf(stderr, "error(%d) trying to perform "
646 "operation\n", res);
647 return -EINVAL;
648 }
649 }
650
651 curl_easy_cleanup(curl);
652 if (session->action == ACTION_UPDATE)
653 curl_formfree(formpost);
654 bti_curl_buffer_free(curl_buf);
655 } else {
656 switch (session->action) {
657 case ACTION_UPDATE:
658 escaped_tweet = oauth_url_escape(session->tweet);
659 if (session->replyto) {
660 sprintf(endpoint,
661 "%s%s?status=%s&in_reply_to_status_id=%s",
662 session->hosturl, update_uri,
663 escaped_tweet, session->replyto);
664 } else {
665 sprintf(endpoint, "%s%s?status=%s",
666 session->hosturl, update_uri,
667 escaped_tweet);
668 }
669
670 is_post = 1;
671 break;
672 case ACTION_USER:
673 sprintf(endpoint, "%s%s%s.xml?page=%d",
674 session->hosturl, user_uri, session->user,
675 session->page);
676 break;
677 case ACTION_REPLIES:
678 sprintf(endpoint, "%s%s?page=%d", session->hosturl,
679 mentions_uri, session->page);
680 break;
681 case ACTION_PUBLIC:
682 sprintf(endpoint, "%s%s?page=%d", session->hosturl,
683 public_uri, session->page);
684 break;
685 case ACTION_GROUP:
686 sprintf(endpoint, "%s%s%s.xml?page=%d",
687 session->hosturl, group_uri, session->group,
688 session->page);
689 break;
690 case ACTION_FRIENDS:
691 sprintf(endpoint, "%s%s?page=%d", session->hosturl,
692 friends_uri, session->page);
693 break;
694 case ACTION_RETWEET:
695 sprintf(endpoint, "%s%s%s.xml", session->hosturl,
696 retweet_uri, session->retweet);
697 is_post = 1;
698 break;
699 default:
700 break;
701 }
702
703 dbg("%s\n", endpoint);
704 if (!session->dry_run) {
705 if (is_post) {
706 req_url = oauth_sign_url2(endpoint, &postarg, OA_HMAC,
707 NULL, session->consumer_key,
708 session->consumer_secret,
709 session->access_token_key,
710 session->access_token_secret);
711 reply = oauth_http_post(req_url, postarg);
712 } else {
713 req_url = oauth_sign_url2(endpoint, NULL, OA_HMAC, NULL,
714 session->consumer_key,
715 session->consumer_secret,
716 session->access_token_key,
717 session->access_token_secret);
718 reply = oauth_http_get(req_url, postarg);
719 }
720
721 dbg("%s\n", req_url);
722 dbg("%s\n", reply);
723 if (req_url)
724 free(req_url);
725 }
726
727 if (!reply) {
728 fprintf(stderr, "Error retrieving from URL (%s)\n", endpoint);
729 return -EIO;
730 }
731
732 if ((session->action != ACTION_UPDATE) &&
733 (session->action != ACTION_RETWEET))
734 parse_timeline(reply, session);
735 }
736 return 0;
737 }
738
739 static void log_session(struct session *session, int retval)
740 {
741 FILE *log_file;
742 char *filename;
743
744 /* Only log something if we have a log file set */
745 if (!session->logfile)
746 return;
747
748 filename = alloca(strlen(session->homedir) +
749 strlen(session->logfile) + 3);
750
751 sprintf(filename, "%s/%s", session->homedir, session->logfile);
752
753 log_file = fopen(filename, "a+");
754 if (log_file == NULL)
755 return;
756
757 switch (session->action) {
758 case ACTION_UPDATE:
759 if (retval)
760 fprintf(log_file, "%s: host=%s tweet failed\n",
761 session->time, session->hostname);
762 else
763 fprintf(log_file, "%s: host=%s tweet=%s\n",
764 session->time, session->hostname,
765 session->tweet);
766 break;
767 case ACTION_FRIENDS:
768 fprintf(log_file, "%s: host=%s retrieving friends timeline\n",
769 session->time, session->hostname);
770 break;
771 case ACTION_USER:
772 fprintf(log_file, "%s: host=%s retrieving %s's timeline\n",
773 session->time, session->hostname, session->user);
774 break;
775 case ACTION_REPLIES:
776 fprintf(log_file, "%s: host=%s retrieving replies\n",
777 session->time, session->hostname);
778 break;
779 case ACTION_PUBLIC:
780 fprintf(log_file, "%s: host=%s retrieving public timeline\n",
781 session->time, session->hostname);
782 break;
783 case ACTION_GROUP:
784 fprintf(log_file, "%s: host=%s retrieving group timeline\n",
785 session->time, session->hostname);
786 break;
787 default:
788 break;
789 }
790
791 fclose(log_file);
792 }
793
794 static char *get_string_from_stdin(void)
795 {
796 char *temp;
797 char *string;
798
799 string = zalloc(1000);
800 if (!string)
801 return NULL;
802
803 if (!fgets(string, 999, stdin))
804 return NULL;
805 temp = strchr(string, '\n');
806 if (temp)
807 *temp = '\0';
808 return string;
809 }
810
811 static void read_password(char *buf, size_t len, char *host)
812 {
813 char pwd[80];
814 int retval;
815 struct termios old;
816 struct termios tp;
817
818 tcgetattr(0, &tp);
819 old = tp;
820
821 tp.c_lflag &= (~ECHO);
822 tcsetattr(0, TCSANOW, &tp);
823
824 fprintf(stdout, "Enter password for %s: ", host);
825 fflush(stdout);
826 tcflow(0, TCOOFF);
827 retval = scanf("%79s", pwd);
828 tcflow(0, TCOON);
829 fprintf(stdout, "\n");
830
831 tcsetattr(0, TCSANOW, &old);
832
833 strncpy(buf, pwd, len);
834 buf[len-1] = '\0';
835 }
836
837 static int find_urls(const char *tweet, int **pranges)
838 {
839 /*
840 * magic obtained from
841 * http://www.geekpedia.com/KB65_How-to-validate-an-URL-using-RegEx-in-Csharp.html
842 */
843 static const char *re_magic =
844 "(([a-zA-Z][0-9a-zA-Z+\\-\\.]*:)/{1,3}"
845 "[0-9a-zA-Z;/~?:@&=+$\\.\\-_'()%]+)"
846 "(#[0-9a-zA-Z;/?:@&=+$\\.\\-_!~*'()%]+)?";
847 pcre *re;
848 const char *errptr;
849 int erroffset;
850 int ovector[10] = {0,};
851 const size_t ovsize = sizeof(ovector)/sizeof(*ovector);
852 int startoffset, tweetlen;
853 int i, rc;
854 int rbound = 10;
855 int rcount = 0;
856 int *ranges = malloc(sizeof(int) * rbound);
857
858 re = pcre_compile(re_magic,
859 PCRE_NO_AUTO_CAPTURE,
860 &errptr, &erroffset, NULL);
861 if (!re) {
862 fprintf(stderr, "pcre_compile @%u: %s\n", erroffset, errptr);
863 exit(1);
864 }
865
866 tweetlen = strlen(tweet);
867 for (startoffset = 0; startoffset < tweetlen; ) {
868
869 rc = pcre_exec(re, NULL, tweet, strlen(tweet), startoffset, 0,
870 ovector, ovsize);
871 if (rc == PCRE_ERROR_NOMATCH)
872 break;
873
874 if (rc < 0) {
875 fprintf(stderr, "pcre_exec @%u: %s\n",
876 erroffset, errptr);
877 exit(1);
878 }
879
880 for (i = 0; i < rc; i += 2) {
881 if ((rcount+2) == rbound) {
882 rbound *= 2;
883 ranges = realloc(ranges, sizeof(int) * rbound);
884 }
885
886 ranges[rcount++] = ovector[i];
887 ranges[rcount++] = ovector[i+1];
888 }
889
890 startoffset = ovector[1];
891 }
892
893 pcre_free(re);
894
895 *pranges = ranges;
896 return rcount;
897 }
898
899 /**
900 * bidirectional popen() call
901 *
902 * @param rwepipe - int array of size three
903 * @param exe - program to run
904 * @param argv - argument list
905 * @return pid or -1 on error
906 *
907 * The caller passes in an array of three integers (rwepipe), on successful
908 * execution it can then write to element 0 (stdin of exe), and read from
909 * element 1 (stdout) and 2 (stderr).
910 */
911 static int popenRWE(int *rwepipe, const char *exe, const char *const argv[])
912 {
913 int in[2];
914 int out[2];
915 int err[2];
916 int pid;
917 int rc;
918
919 rc = pipe(in);
920 if (rc < 0)
921 goto error_in;
922
923 rc = pipe(out);
924 if (rc < 0)
925 goto error_out;
926
927 rc = pipe(err);
928 if (rc < 0)
929 goto error_err;
930
931 pid = fork();
932 if (pid > 0) {
933 /* parent */
934 close(in[0]);
935 close(out[1]);
936 close(err[1]);
937 rwepipe[0] = in[1];
938 rwepipe[1] = out[0];
939 rwepipe[2] = err[0];
940 return pid;
941 } else if (pid == 0) {
942 /* child */
943 close(in[1]);
944 close(out[0]);
945 close(err[0]);
946 close(0);
947 rc = dup(in[0]);
948 close(1);
949 rc = dup(out[1]);
950 close(2);
951 rc = dup(err[1]);
952
953 execvp(exe, (char **)argv);
954 exit(1);
955 } else
956 goto error_fork;
957
958 return pid;
959
960 error_fork:
961 close(err[0]);
962 close(err[1]);
963 error_err:
964 close(out[0]);
965 close(out[1]);
966 error_out:
967 close(in[0]);
968 close(in[1]);
969 error_in:
970 return -1;
971 }
972
973 static int pcloseRWE(int pid, int *rwepipe)
974 {
975 int rc, status;
976 close(rwepipe[0]);
977 close(rwepipe[1]);
978 close(rwepipe[2]);
979 rc = waitpid(pid, &status, 0);
980 return status;
981 }
982
983 static char *shrink_one_url(int *rwepipe, char *big)
984 {
985 int biglen = strlen(big);
986 char *small;
987 int smalllen;
988 int rc;
989
990 rc = dprintf(rwepipe[0], "%s\n", big);
991 if (rc < 0)
992 return big;
993
994 smalllen = biglen + 128;
995 small = malloc(smalllen);
996 if (!small)
997 return big;
998
999 rc = read(rwepipe[1], small, smalllen);
1000 if (rc < 0 || rc > biglen)
1001 goto error_free_small;
1002
1003 if (strncmp(small, "http://", 7))
1004 goto error_free_small;
1005
1006 smalllen = rc;
1007 while (smalllen && isspace(small[smalllen-1]))
1008 small[--smalllen] = 0;
1009
1010 free(big);
1011 return small;
1012
1013 error_free_small:
1014 free(small);
1015 return big;
1016 }
1017
1018 static char *shrink_urls(char *text)
1019 {
1020 int *ranges;
1021 int rcount;
1022 int i;
1023 int inofs = 0;
1024 int outofs = 0;
1025 const char *const shrink_args[] = {
1026 "bti-shrink-urls",
1027 NULL
1028 };
1029 int shrink_pid;
1030 int shrink_pipe[3];
1031 int inlen = strlen(text);
1032
1033 dbg("before len=%u\n", inlen);
1034
1035 shrink_pid = popenRWE(shrink_pipe, shrink_args[0], shrink_args);
1036 if (shrink_pid < 0)
1037 return text;
1038
1039 rcount = find_urls(text, &ranges);
1040 if (!rcount)
1041 return text;
1042
1043 for (i = 0; i < rcount; i += 2) {
1044 int url_start = ranges[i];
1045 int url_end = ranges[i+1];
1046 int long_url_len = url_end - url_start;
1047 char *url = strndup(text + url_start, long_url_len);
1048 int short_url_len;
1049 int not_url_len = url_start - inofs;
1050
1051 dbg("long url[%u]: %s\n", long_url_len, url);
1052 url = shrink_one_url(shrink_pipe, url);
1053 short_url_len = url ? strlen(url) : 0;
1054 dbg("short url[%u]: %s\n", short_url_len, url);
1055
1056 if (!url || short_url_len >= long_url_len) {
1057 /* The short url ended up being too long
1058 * or unavailable */
1059 if (inofs) {
1060 strncpy(text + outofs, text + inofs,
1061 not_url_len + long_url_len);
1062 }
1063 inofs += not_url_len + long_url_len;
1064 outofs += not_url_len + long_url_len;
1065
1066 } else {
1067 /* copy the unmodified block */
1068 strncpy(text + outofs, text + inofs, not_url_len);
1069 inofs += not_url_len;
1070 outofs += not_url_len;
1071
1072 /* copy the new url */
1073 strncpy(text + outofs, url, short_url_len);
1074 inofs += long_url_len;
1075 outofs += short_url_len;
1076 }
1077
1078 free(url);
1079 }
1080
1081 /* copy the last block after the last match */
1082 if (inofs) {
1083 int tail = inlen - inofs;
1084 if (tail) {
1085 strncpy(text + outofs, text + inofs, tail);
1086 outofs += tail;
1087 }
1088 }
1089
1090 free(ranges);
1091
1092 (void)pcloseRWE(shrink_pid, shrink_pipe);
1093
1094 text[outofs] = 0;
1095 dbg("after len=%u\n", outofs);
1096 return text;
1097 }
1098
1099 int main(int argc, char *argv[], char *envp[])
1100 {
1101 static const struct option options[] = {
1102 { "debug", 0, NULL, 'd' },
1103 { "verbose", 0, NULL, 'V' },
1104 { "account", 1, NULL, 'a' },
1105 { "password", 1, NULL, 'p' },
1106 { "host", 1, NULL, 'H' },
1107 { "proxy", 1, NULL, 'P' },
1108 { "action", 1, NULL, 'A' },
1109 { "user", 1, NULL, 'u' },
1110 { "group", 1, NULL, 'G' },
1111 { "logfile", 1, NULL, 'L' },
1112 { "shrink-urls", 0, NULL, 's' },
1113 { "help", 0, NULL, 'h' },
1114 { "bash", 0, NULL, 'b' },
1115 { "background", 0, NULL, 'B' },
1116 { "dry-run", 0, NULL, 'n' },
1117 { "page", 1, NULL, 'g' },
1118 { "version", 0, NULL, 'v' },
1119 { "config", 1, NULL, 'c' },
1120 { "replyto", 1, NULL, 'r' },
1121 { "retweet", 1, NULL, 'w' },
1122 { }
1123 };
1124 struct session *session;
1125 pid_t child;
1126 char *tweet;
1127 static char password[80];
1128 int retval = 0;
1129 int option;
1130 char *http_proxy;
1131 time_t t;
1132 int page_nr;
1133
1134 debug = 0;
1135
1136 session = session_alloc();
1137 if (!session) {
1138 fprintf(stderr, "no more memory...\n");
1139 return -1;
1140 }
1141
1142 /* get the current time so that we can log it later */
1143 time(&t);
1144 session->time = strdup(ctime(&t));
1145 session->time[strlen(session->time)-1] = 0x00;
1146
1147 /* Get the home directory so we can try to find a config file */
1148 session->homedir = strdup(getenv("HOME"));
1149
1150 /* set up a default config file location (traditionally ~/.bti) */
1151 session->configfile = zalloc(strlen(session->homedir) + 7);
1152 sprintf(session->configfile, "%s/.bti", session->homedir);
1153
1154 /* Set environment variables first, before reading command line options
1155 * or config file values. */
1156 http_proxy = getenv("http_proxy");
1157 if (http_proxy) {
1158 if (session->proxy)
1159 free(session->proxy);
1160 session->proxy = strdup(http_proxy);
1161 dbg("http_proxy = %s\n", session->proxy);
1162 }
1163
1164 bti_parse_configfile(session);
1165
1166 while (1) {
1167 option = getopt_long_only(argc, argv,
1168 "dp:P:H:a:A:u:c:hg:G:sr:nVvw:",
1169 options, NULL);
1170 if (option == -1)
1171 break;
1172 switch (option) {
1173 case 'd':
1174 debug = 1;
1175 break;
1176 case 'V':
1177 session->verbose = 1;
1178 break;
1179 case 'a':
1180 if (session->account)
1181 free(session->account);
1182 session->account = strdup(optarg);
1183 dbg("account = %s\n", session->account);
1184 break;
1185 case 'g':
1186 page_nr = atoi(optarg);
1187 dbg("page = %d\n", page_nr);
1188 session->page = page_nr;
1189 break;
1190 case 'r':
1191 session->replyto = strdup(optarg);
1192 dbg("in_reply_to_status_id = %s\n", session->replyto);
1193 break;
1194 case 'w':
1195 session->retweet = strdup(optarg);
1196 dbg("Retweet ID = %s\n", session->retweet);
1197 break;
1198 case 'p':
1199 if (session->password)
1200 free(session->password);
1201 session->password = strdup(optarg);
1202 dbg("password = %s\n", session->password);
1203 break;
1204 case 'P':
1205 if (session->proxy)
1206 free(session->proxy);
1207 session->proxy = strdup(optarg);
1208 dbg("proxy = %s\n", session->proxy);
1209 break;
1210 case 'A':
1211 if (strcasecmp(optarg, "update") == 0)
1212 session->action = ACTION_UPDATE;
1213 else if (strcasecmp(optarg, "friends") == 0)
1214 session->action = ACTION_FRIENDS;
1215 else if (strcasecmp(optarg, "user") == 0)
1216 session->action = ACTION_USER;
1217 else if (strcasecmp(optarg, "replies") == 0)
1218 session->action = ACTION_REPLIES;
1219 else if (strcasecmp(optarg, "public") == 0)
1220 session->action = ACTION_PUBLIC;
1221 else if (strcasecmp(optarg, "group") == 0)
1222 session->action = ACTION_GROUP;
1223 else if (strcasecmp(optarg,"retweet") == 0)
1224 session->action = ACTION_RETWEET;
1225 else
1226 session->action = ACTION_UNKNOWN;
1227 dbg("action = %d\n", session->action);
1228 break;
1229 case 'u':
1230 if (session->user)
1231 free(session->user);
1232 session->user = strdup(optarg);
1233 dbg("user = %s\n", session->user);
1234 break;
1235
1236 case 'G':
1237 if (session->group)
1238 free(session->group);
1239 session->group = strdup(optarg);
1240 dbg("group = %s\n", session->group);
1241 break;
1242 case 'L':
1243 if (session->logfile)
1244 free(session->logfile);
1245 session->logfile = strdup(optarg);
1246 dbg("logfile = %s\n", session->logfile);
1247 break;
1248 case 's':
1249 session->shrink_urls = 1;
1250 break;
1251 case 'H':
1252 if (session->hosturl)
1253 free(session->hosturl);
1254 if (session->hostname)
1255 free(session->hostname);
1256 if (strcasecmp(optarg, "twitter") == 0) {
1257 session->host = HOST_TWITTER;
1258 session->hosturl = strdup(twitter_host);
1259 session->hostname = strdup(twitter_name);
1260 } else if (strcasecmp(optarg, "identica") == 0) {
1261 session->host = HOST_IDENTICA;
1262 session->hosturl = strdup(identica_host);
1263 session->hostname = strdup(identica_name);
1264 } else {
1265 session->host = HOST_CUSTOM;
1266 session->hosturl = strdup(optarg);
1267 session->hostname = strdup(optarg);
1268 }
1269 dbg("host = %d\n", session->host);
1270 break;
1271 case 'b':
1272 session->bash = 1;
1273 /* fall-through intended */
1274 case 'B':
1275 session->background = 1;
1276 break;
1277 case 'c':
1278 if (session->configfile)
1279 free(session->configfile);
1280 session->configfile = strdup(optarg);
1281 dbg("configfile = %s\n", session->configfile);
1282
1283 /*
1284 * read the config file now. Yes, this could override
1285 * previously set options from the command line, but
1286 * the user asked for it...
1287 */
1288 bti_parse_configfile(session);
1289 break;
1290 case 'h':
1291 display_help();
1292 goto exit;
1293 case 'n':
1294 session->dry_run = 1;
1295 break;
1296 case 'v':
1297 display_version();
1298 goto exit;
1299 default:
1300 display_help();
1301 goto exit;
1302 }
1303 }
1304
1305 session_readline_init(session);
1306 /*
1307 * Show the version to make it easier to determine what
1308 * is going on here
1309 */
1310 if (debug)
1311 display_version();
1312
1313 if (session->host == HOST_TWITTER) {
1314 if (!session->consumer_key || !session->consumer_secret) {
1315 if (session->action == ACTION_USER ||
1316 session->action == ACTION_PUBLIC) {
1317 /* Some actions may still work without authentication */
1318 session->guest = 1;
1319 } else {
1320 fprintf(stderr,
1321 "Twitter no longer supports HTTP basic authentication.\n"
1322 "Both consumer key, and consumer secret are required"
1323 " for bti in order to behave as an OAuth consumer.\n");
1324 goto exit;
1325 }
1326 }
1327 if (session->action == ACTION_GROUP) {
1328 fprintf(stderr, "Groups only work in Identi.ca.\n");
1329 goto exit;
1330 }
1331 } else {
1332 if (!session->consumer_key || !session->consumer_secret)
1333 session->no_oauth = 1;
1334 }
1335
1336 if (session->no_oauth) {
1337 if (!session->account) {
1338 fprintf(stdout, "Enter account for %s: ",
1339 session->hostname);
1340 session->account = session->readline(NULL);
1341 }
1342 if (!session->password) {
1343 read_password(password, sizeof(password),
1344 session->hostname);
1345 session->password = strdup(password);
1346 }
1347 } else if (!session->guest) {
1348 if (!session->access_token_key ||
1349 !session->access_token_secret) {
1350 request_access_token(session);
1351 goto exit;
1352 }
1353 }
1354
1355 if (session->action == ACTION_UNKNOWN) {
1356 fprintf(stderr, "Unknown action, valid actions are:\n"
1357 "'update', 'friends', 'public', 'replies', 'group' or 'user'.\n");
1358 goto exit;
1359 }
1360
1361 if (session->action == ACTION_GROUP && !session->group) {
1362 fprintf(stdout, "Enter group name: ");
1363 session->group = session->readline(NULL);
1364 }
1365
1366 if (session->action == ACTION_RETWEET) {
1367 if (!session->retweet) {
1368 char *rtid;
1369
1370 fprintf(stdout, "Status ID to retweet: ");
1371 rtid = get_string_from_stdin();
1372 session->retweet = zalloc(strlen(rtid) + 10);
1373 sprintf(session->retweet,"%s", rtid);
1374 free(rtid);
1375 }
1376
1377 if (!session->retweet || strlen(session->retweet) == 0) {
1378 dbg("no retweet?\n");
1379 return -1;
1380 }
1381
1382 dbg("retweet ID = %s\n", session->retweet);
1383 }
1384
1385 if (session->action == ACTION_UPDATE) {
1386 if (session->background || !session->interactive)
1387 tweet = get_string_from_stdin();
1388 else
1389 tweet = session->readline("tweet: ");
1390 if (!tweet || strlen(tweet) == 0) {
1391 dbg("no tweet?\n");
1392 return -1;
1393 }
1394
1395 if (session->shrink_urls)
1396 tweet = shrink_urls(tweet);
1397
1398 session->tweet = zalloc(strlen(tweet) + 10);
1399 if (session->bash)
1400 sprintf(session->tweet, "%c %s",
1401 getuid() ? '$' : '#', tweet);
1402 else
1403 sprintf(session->tweet, "%s", tweet);
1404
1405 free(tweet);
1406 dbg("tweet = %s\n", session->tweet);
1407 }
1408
1409 if (session->page == 0)
1410 session->page = 1;
1411 dbg("config file = %s\n", session->configfile);
1412 dbg("host = %d\n", session->host);
1413 dbg("action = %d\n", session->action);
1414
1415 /* fork ourself so that the main shell can get on
1416 * with it's life as we try to connect and handle everything
1417 */
1418 if (session->background) {
1419 child = fork();
1420 if (child) {
1421 dbg("child is %d\n", child);
1422 exit(0);
1423 }
1424 }
1425
1426 retval = send_request(session);
1427 if (retval && !session->background)
1428 fprintf(stderr, "operation failed\n");
1429
1430 log_session(session, retval);
1431 exit:
1432 session_readline_cleanup(session);
1433 session_free(session);
1434 return retval;;
1435 }

  ViewVC Help
Powered by ViewVC 1.1.26