/[debian]/bti/trunk/bti.c
ViewVC logotype

Contents of /bti/trunk/bti.c

Parent Directory Parent Directory | Revision Log Revision Log


Revision 2338 - (show annotations)
Fri Jan 14 01:23:13 2011 UTC (10 years ago) by gregoa
File MIME type: text/plain
File size: 35355 byte(s)
* New upstream release: includes fixes for
  - "the --dry-run option has no effect (tweets get posted anyway)
     with OAuth" (closes: #608608)
  - "--replyto doesn't work with OAuth" (closes: #608112)
* Drop patch 0001-Fixing-Identi.ca-s-OAuth-request_token-URI.patch, applied
  upstream.
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 static 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 bti_output_line(struct session *session, xmlChar *user, xmlChar *id,
288 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 ((session->action != ACTION_UPDATE) &&
728 (session->action != ACTION_RETWEET))
729 parse_timeline(reply, session);
730 }
731 return 0;
732 }
733
734 static void log_session(struct session *session, int retval)
735 {
736 FILE *log_file;
737 char *filename;
738
739 /* Only log something if we have a log file set */
740 if (!session->logfile)
741 return;
742
743 filename = alloca(strlen(session->homedir) +
744 strlen(session->logfile) + 3);
745
746 sprintf(filename, "%s/%s", session->homedir, session->logfile);
747
748 log_file = fopen(filename, "a+");
749 if (log_file == NULL)
750 return;
751
752 switch (session->action) {
753 case ACTION_UPDATE:
754 if (retval)
755 fprintf(log_file, "%s: host=%s tweet failed\n",
756 session->time, session->hostname);
757 else
758 fprintf(log_file, "%s: host=%s tweet=%s\n",
759 session->time, session->hostname,
760 session->tweet);
761 break;
762 case ACTION_FRIENDS:
763 fprintf(log_file, "%s: host=%s retrieving friends timeline\n",
764 session->time, session->hostname);
765 break;
766 case ACTION_USER:
767 fprintf(log_file, "%s: host=%s retrieving %s's timeline\n",
768 session->time, session->hostname, session->user);
769 break;
770 case ACTION_REPLIES:
771 fprintf(log_file, "%s: host=%s retrieving replies\n",
772 session->time, session->hostname);
773 break;
774 case ACTION_PUBLIC:
775 fprintf(log_file, "%s: host=%s retrieving public timeline\n",
776 session->time, session->hostname);
777 break;
778 case ACTION_GROUP:
779 fprintf(log_file, "%s: host=%s retrieving group timeline\n",
780 session->time, session->hostname);
781 break;
782 default:
783 break;
784 }
785
786 fclose(log_file);
787 }
788
789 static char *get_string_from_stdin(void)
790 {
791 char *temp;
792 char *string;
793
794 string = zalloc(1000);
795 if (!string)
796 return NULL;
797
798 if (!fgets(string, 999, stdin))
799 return NULL;
800 temp = strchr(string, '\n');
801 if (temp)
802 *temp = '\0';
803 return string;
804 }
805
806 static void read_password(char *buf, size_t len, char *host)
807 {
808 char pwd[80];
809 int retval;
810 struct termios old;
811 struct termios tp;
812
813 tcgetattr(0, &tp);
814 old = tp;
815
816 tp.c_lflag &= (~ECHO);
817 tcsetattr(0, TCSANOW, &tp);
818
819 fprintf(stdout, "Enter password for %s: ", host);
820 fflush(stdout);
821 tcflow(0, TCOOFF);
822 retval = scanf("%79s", pwd);
823 tcflow(0, TCOON);
824 fprintf(stdout, "\n");
825
826 tcsetattr(0, TCSANOW, &old);
827
828 strncpy(buf, pwd, len);
829 buf[len-1] = '\0';
830 }
831
832 static int find_urls(const char *tweet, int **pranges)
833 {
834 /*
835 * magic obtained from
836 * http://www.geekpedia.com/KB65_How-to-validate-an-URL-using-RegEx-in-Csharp.html
837 */
838 static const char *re_magic =
839 "(([a-zA-Z][0-9a-zA-Z+\\-\\.]*:)/{1,3}"
840 "[0-9a-zA-Z;/~?:@&=+$\\.\\-_'()%]+)"
841 "(#[0-9a-zA-Z;/?:@&=+$\\.\\-_!~*'()%]+)?";
842 pcre *re;
843 const char *errptr;
844 int erroffset;
845 int ovector[10] = {0,};
846 const size_t ovsize = sizeof(ovector)/sizeof(*ovector);
847 int startoffset, tweetlen;
848 int i, rc;
849 int rbound = 10;
850 int rcount = 0;
851 int *ranges = malloc(sizeof(int) * rbound);
852
853 re = pcre_compile(re_magic,
854 PCRE_NO_AUTO_CAPTURE,
855 &errptr, &erroffset, NULL);
856 if (!re) {
857 fprintf(stderr, "pcre_compile @%u: %s\n", erroffset, errptr);
858 exit(1);
859 }
860
861 tweetlen = strlen(tweet);
862 for (startoffset = 0; startoffset < tweetlen; ) {
863
864 rc = pcre_exec(re, NULL, tweet, strlen(tweet), startoffset, 0,
865 ovector, ovsize);
866 if (rc == PCRE_ERROR_NOMATCH)
867 break;
868
869 if (rc < 0) {
870 fprintf(stderr, "pcre_exec @%u: %s\n",
871 erroffset, errptr);
872 exit(1);
873 }
874
875 for (i = 0; i < rc; i += 2) {
876 if ((rcount+2) == rbound) {
877 rbound *= 2;
878 ranges = realloc(ranges, sizeof(int) * rbound);
879 }
880
881 ranges[rcount++] = ovector[i];
882 ranges[rcount++] = ovector[i+1];
883 }
884
885 startoffset = ovector[1];
886 }
887
888 pcre_free(re);
889
890 *pranges = ranges;
891 return rcount;
892 }
893
894 /**
895 * bidirectional popen() call
896 *
897 * @param rwepipe - int array of size three
898 * @param exe - program to run
899 * @param argv - argument list
900 * @return pid or -1 on error
901 *
902 * The caller passes in an array of three integers (rwepipe), on successful
903 * execution it can then write to element 0 (stdin of exe), and read from
904 * element 1 (stdout) and 2 (stderr).
905 */
906 static int popenRWE(int *rwepipe, const char *exe, const char *const argv[])
907 {
908 int in[2];
909 int out[2];
910 int err[2];
911 int pid;
912 int rc;
913
914 rc = pipe(in);
915 if (rc < 0)
916 goto error_in;
917
918 rc = pipe(out);
919 if (rc < 0)
920 goto error_out;
921
922 rc = pipe(err);
923 if (rc < 0)
924 goto error_err;
925
926 pid = fork();
927 if (pid > 0) {
928 /* parent */
929 close(in[0]);
930 close(out[1]);
931 close(err[1]);
932 rwepipe[0] = in[1];
933 rwepipe[1] = out[0];
934 rwepipe[2] = err[0];
935 return pid;
936 } else if (pid == 0) {
937 /* child */
938 close(in[1]);
939 close(out[0]);
940 close(err[0]);
941 close(0);
942 rc = dup(in[0]);
943 close(1);
944 rc = dup(out[1]);
945 close(2);
946 rc = dup(err[1]);
947
948 execvp(exe, (char **)argv);
949 exit(1);
950 } else
951 goto error_fork;
952
953 return pid;
954
955 error_fork:
956 close(err[0]);
957 close(err[1]);
958 error_err:
959 close(out[0]);
960 close(out[1]);
961 error_out:
962 close(in[0]);
963 close(in[1]);
964 error_in:
965 return -1;
966 }
967
968 static int pcloseRWE(int pid, int *rwepipe)
969 {
970 int rc, status;
971 close(rwepipe[0]);
972 close(rwepipe[1]);
973 close(rwepipe[2]);
974 rc = waitpid(pid, &status, 0);
975 return status;
976 }
977
978 static char *shrink_one_url(int *rwepipe, char *big)
979 {
980 int biglen = strlen(big);
981 char *small;
982 int smalllen;
983 int rc;
984
985 rc = dprintf(rwepipe[0], "%s\n", big);
986 if (rc < 0)
987 return big;
988
989 smalllen = biglen + 128;
990 small = malloc(smalllen);
991 if (!small)
992 return big;
993
994 rc = read(rwepipe[1], small, smalllen);
995 if (rc < 0 || rc > biglen)
996 goto error_free_small;
997
998 if (strncmp(small, "http://", 7))
999 goto error_free_small;
1000
1001 smalllen = rc;
1002 while (smalllen && isspace(small[smalllen-1]))
1003 small[--smalllen] = 0;
1004
1005 free(big);
1006 return small;
1007
1008 error_free_small:
1009 free(small);
1010 return big;
1011 }
1012
1013 static char *shrink_urls(char *text)
1014 {
1015 int *ranges;
1016 int rcount;
1017 int i;
1018 int inofs = 0;
1019 int outofs = 0;
1020 const char *const shrink_args[] = {
1021 "bti-shrink-urls",
1022 NULL
1023 };
1024 int shrink_pid;
1025 int shrink_pipe[3];
1026 int inlen = strlen(text);
1027
1028 dbg("before len=%u\n", inlen);
1029
1030 shrink_pid = popenRWE(shrink_pipe, shrink_args[0], shrink_args);
1031 if (shrink_pid < 0)
1032 return text;
1033
1034 rcount = find_urls(text, &ranges);
1035 if (!rcount)
1036 return text;
1037
1038 for (i = 0; i < rcount; i += 2) {
1039 int url_start = ranges[i];
1040 int url_end = ranges[i+1];
1041 int long_url_len = url_end - url_start;
1042 char *url = strndup(text + url_start, long_url_len);
1043 int short_url_len;
1044 int not_url_len = url_start - inofs;
1045
1046 dbg("long url[%u]: %s\n", long_url_len, url);
1047 url = shrink_one_url(shrink_pipe, url);
1048 short_url_len = url ? strlen(url) : 0;
1049 dbg("short url[%u]: %s\n", short_url_len, url);
1050
1051 if (!url || short_url_len >= long_url_len) {
1052 /* The short url ended up being too long
1053 * or unavailable */
1054 if (inofs) {
1055 strncpy(text + outofs, text + inofs,
1056 not_url_len + long_url_len);
1057 }
1058 inofs += not_url_len + long_url_len;
1059 outofs += not_url_len + long_url_len;
1060
1061 } else {
1062 /* copy the unmodified block */
1063 strncpy(text + outofs, text + inofs, not_url_len);
1064 inofs += not_url_len;
1065 outofs += not_url_len;
1066
1067 /* copy the new url */
1068 strncpy(text + outofs, url, short_url_len);
1069 inofs += long_url_len;
1070 outofs += short_url_len;
1071 }
1072
1073 free(url);
1074 }
1075
1076 /* copy the last block after the last match */
1077 if (inofs) {
1078 int tail = inlen - inofs;
1079 if (tail) {
1080 strncpy(text + outofs, text + inofs, tail);
1081 outofs += tail;
1082 }
1083 }
1084
1085 free(ranges);
1086
1087 (void)pcloseRWE(shrink_pid, shrink_pipe);
1088
1089 text[outofs] = 0;
1090 dbg("after len=%u\n", outofs);
1091 return text;
1092 }
1093
1094 int main(int argc, char *argv[], char *envp[])
1095 {
1096 static const struct option options[] = {
1097 { "debug", 0, NULL, 'd' },
1098 { "verbose", 0, NULL, 'V' },
1099 { "account", 1, NULL, 'a' },
1100 { "password", 1, NULL, 'p' },
1101 { "host", 1, NULL, 'H' },
1102 { "proxy", 1, NULL, 'P' },
1103 { "action", 1, NULL, 'A' },
1104 { "user", 1, NULL, 'u' },
1105 { "group", 1, NULL, 'G' },
1106 { "logfile", 1, NULL, 'L' },
1107 { "shrink-urls", 0, NULL, 's' },
1108 { "help", 0, NULL, 'h' },
1109 { "bash", 0, NULL, 'b' },
1110 { "background", 0, NULL, 'B' },
1111 { "dry-run", 0, NULL, 'n' },
1112 { "page", 1, NULL, 'g' },
1113 { "version", 0, NULL, 'v' },
1114 { "config", 1, NULL, 'c' },
1115 { "replyto", 1, NULL, 'r' },
1116 { "retweet", 1, NULL, 'w' },
1117 { }
1118 };
1119 struct session *session;
1120 pid_t child;
1121 char *tweet;
1122 char *retweet;
1123 static char password[80];
1124 int retval = 0;
1125 int option;
1126 char *http_proxy;
1127 time_t t;
1128 int page_nr;
1129
1130 debug = 0;
1131
1132 session = session_alloc();
1133 if (!session) {
1134 fprintf(stderr, "no more memory...\n");
1135 return -1;
1136 }
1137
1138 /* get the current time so that we can log it later */
1139 time(&t);
1140 session->time = strdup(ctime(&t));
1141 session->time[strlen(session->time)-1] = 0x00;
1142
1143 /* Get the home directory so we can try to find a config file */
1144 session->homedir = strdup(getenv("HOME"));
1145
1146 /* set up a default config file location (traditionally ~/.bti) */
1147 session->configfile = zalloc(strlen(session->homedir) + 7);
1148 sprintf(session->configfile, "%s/.bti", session->homedir);
1149
1150 /* Set environment variables first, before reading command line options
1151 * or config file values. */
1152 http_proxy = getenv("http_proxy");
1153 if (http_proxy) {
1154 if (session->proxy)
1155 free(session->proxy);
1156 session->proxy = strdup(http_proxy);
1157 dbg("http_proxy = %s\n", session->proxy);
1158 }
1159
1160 bti_parse_configfile(session);
1161
1162 while (1) {
1163 option = getopt_long_only(argc, argv,
1164 "dp:P:H:a:A:u:c:hg:G:sr:nVv",
1165 options, NULL);
1166 if (option == -1)
1167 break;
1168 switch (option) {
1169 case 'd':
1170 debug = 1;
1171 break;
1172 case 'V':
1173 session->verbose = 1;
1174 break;
1175 case 'a':
1176 if (session->account)
1177 free(session->account);
1178 session->account = strdup(optarg);
1179 dbg("account = %s\n", session->account);
1180 break;
1181 case 'g':
1182 page_nr = atoi(optarg);
1183 dbg("page = %d\n", page_nr);
1184 session->page = page_nr;
1185 break;
1186 case 'r':
1187 session->replyto = strdup(optarg);
1188 dbg("in_reply_to_status_id = %s\n", session->replyto);
1189 break;
1190 case 'w':
1191 session->retweet = strdup(optarg);
1192 dbg("Retweet ID = %s\n", session->retweet);
1193 break;
1194 case 'p':
1195 if (session->password)
1196 free(session->password);
1197 session->password = strdup(optarg);
1198 dbg("password = %s\n", session->password);
1199 break;
1200 case 'P':
1201 if (session->proxy)
1202 free(session->proxy);
1203 session->proxy = strdup(optarg);
1204 dbg("proxy = %s\n", session->proxy);
1205 break;
1206 case 'A':
1207 if (strcasecmp(optarg, "update") == 0)
1208 session->action = ACTION_UPDATE;
1209 else if (strcasecmp(optarg, "friends") == 0)
1210 session->action = ACTION_FRIENDS;
1211 else if (strcasecmp(optarg, "user") == 0)
1212 session->action = ACTION_USER;
1213 else if (strcasecmp(optarg, "replies") == 0)
1214 session->action = ACTION_REPLIES;
1215 else if (strcasecmp(optarg, "public") == 0)
1216 session->action = ACTION_PUBLIC;
1217 else if (strcasecmp(optarg, "group") == 0)
1218 session->action = ACTION_GROUP;
1219 else if (strcasecmp(optarg,"retweet") == 0)
1220 session->action = ACTION_RETWEET;
1221 else
1222 session->action = ACTION_UNKNOWN;
1223 dbg("action = %d\n", session->action);
1224 break;
1225 case 'u':
1226 if (session->user)
1227 free(session->user);
1228 session->user = strdup(optarg);
1229 dbg("user = %s\n", session->user);
1230 break;
1231
1232 case 'G':
1233 if (session->group)
1234 free(session->group);
1235 session->group = strdup(optarg);
1236 dbg("group = %s\n", session->group);
1237 break;
1238 case 'L':
1239 if (session->logfile)
1240 free(session->logfile);
1241 session->logfile = strdup(optarg);
1242 dbg("logfile = %s\n", session->logfile);
1243 break;
1244 case 's':
1245 session->shrink_urls = 1;
1246 break;
1247 case 'H':
1248 if (session->hosturl)
1249 free(session->hosturl);
1250 if (session->hostname)
1251 free(session->hostname);
1252 if (strcasecmp(optarg, "twitter") == 0) {
1253 session->host = HOST_TWITTER;
1254 session->hosturl = strdup(twitter_host);
1255 session->hostname = strdup(twitter_name);
1256 } else if (strcasecmp(optarg, "identica") == 0) {
1257 session->host = HOST_IDENTICA;
1258 session->hosturl = strdup(identica_host);
1259 session->hostname = strdup(identica_name);
1260 } else {
1261 session->host = HOST_CUSTOM;
1262 session->hosturl = strdup(optarg);
1263 session->hostname = strdup(optarg);
1264 }
1265 dbg("host = %d\n", session->host);
1266 break;
1267 case 'b':
1268 session->bash = 1;
1269 /* fall-through intended */
1270 case 'B':
1271 session->background = 1;
1272 break;
1273 case 'c':
1274 if (session->configfile)
1275 free(session->configfile);
1276 session->configfile = strdup(optarg);
1277 dbg("configfile = %s\n", session->configfile);
1278
1279 /*
1280 * read the config file now. Yes, this could override
1281 * previously set options from the command line, but
1282 * the user asked for it...
1283 */
1284 bti_parse_configfile(session);
1285 break;
1286 case 'h':
1287 display_help();
1288 goto exit;
1289 case 'n':
1290 session->dry_run = 1;
1291 break;
1292 case 'v':
1293 display_version();
1294 goto exit;
1295 default:
1296 display_help();
1297 goto exit;
1298 }
1299 }
1300
1301 session_readline_init(session);
1302 /*
1303 * Show the version to make it easier to determine what
1304 * is going on here
1305 */
1306 if (debug)
1307 display_version();
1308
1309 if (session->host == HOST_TWITTER) {
1310 if (!session->consumer_key || !session->consumer_secret) {
1311 if (session->action == ACTION_USER ||
1312 session->action == ACTION_PUBLIC) {
1313 /* Some actions may still work without authentication */
1314 session->guest = 1;
1315 } else {
1316 fprintf(stderr,
1317 "Twitter no longer supports HTTP basic authentication.\n"
1318 "Both consumer key, and consumer secret are required"
1319 " for bti in order to behave as an OAuth consumer.\n");
1320 goto exit;
1321 }
1322 }
1323 if (session->action == ACTION_GROUP) {
1324 fprintf(stderr, "Groups only work in Identi.ca.\n");
1325 goto exit;
1326 }
1327 } else {
1328 if (!session->consumer_key || !session->consumer_secret)
1329 session->no_oauth = 1;
1330 }
1331
1332 if (session->no_oauth) {
1333 if (!session->account) {
1334 fprintf(stdout, "Enter account for %s: ",
1335 session->hostname);
1336 session->account = session->readline(NULL);
1337 }
1338 if (!session->password) {
1339 read_password(password, sizeof(password),
1340 session->hostname);
1341 session->password = strdup(password);
1342 }
1343 } else if (!session->guest) {
1344 if (!session->access_token_key ||
1345 !session->access_token_secret) {
1346 request_access_token(session);
1347 goto exit;
1348 }
1349 }
1350
1351 if (session->action == ACTION_UNKNOWN) {
1352 fprintf(stderr, "Unknown action, valid actions are:\n"
1353 "'update', 'friends', 'public', 'replies', 'group' or 'user'.\n");
1354 goto exit;
1355 }
1356
1357 if (session->action == ACTION_GROUP && !session->group) {
1358 fprintf(stdout, "Enter group name: ");
1359 session->group = session->readline(NULL);
1360 }
1361
1362 if (session->action == ACTION_RETWEET) {
1363 fprintf(stdout, "Status ID to retweet: ");
1364 retweet = get_string_from_stdin();
1365
1366 if (!retweet || strlen(retweet) == 0) {
1367 dbg("no retweet?\n");
1368 return -1;
1369 }
1370
1371 session->retweet = zalloc(strlen(retweet) + 10);
1372 sprintf(session->retweet,"%s", retweet);
1373 free(retweet);
1374 dbg("retweet ID = %s\n", session->retweet);
1375 }
1376
1377 if (session->action == ACTION_UPDATE) {
1378 if (session->background || !session->interactive)
1379 tweet = get_string_from_stdin();
1380 else
1381 tweet = session->readline("tweet: ");
1382 if (!tweet || strlen(tweet) == 0) {
1383 dbg("no tweet?\n");
1384 return -1;
1385 }
1386
1387 if (session->shrink_urls)
1388 tweet = shrink_urls(tweet);
1389
1390 session->tweet = zalloc(strlen(tweet) + 10);
1391 if (session->bash)
1392 sprintf(session->tweet, "%c %s",
1393 getuid() ? '$' : '#', tweet);
1394 else
1395 sprintf(session->tweet, "%s", tweet);
1396
1397 free(tweet);
1398 dbg("tweet = %s\n", session->tweet);
1399 }
1400
1401 if (session->page == 0)
1402 session->page = 1;
1403 dbg("config file = %s\n", session->configfile);
1404 dbg("host = %d\n", session->host);
1405 dbg("action = %d\n", session->action);
1406
1407 /* fork ourself so that the main shell can get on
1408 * with it's life as we try to connect and handle everything
1409 */
1410 if (session->background) {
1411 child = fork();
1412 if (child) {
1413 dbg("child is %d\n", child);
1414 exit(0);
1415 }
1416 }
1417
1418 retval = send_request(session);
1419 if (retval && !session->background)
1420 fprintf(stderr, "operation failed\n");
1421
1422 log_session(session, retval);
1423 exit:
1424 session_readline_cleanup(session);
1425 session_free(session);
1426 return retval;;
1427 }

  ViewVC Help
Powered by ViewVC 1.1.26