root/lang/cplusplus/twitter-v8/trunk/twitter.cc

#include <v8.h>
#include <cstring>
#include <cstdio>
#include <cstdlib>
#include <curl/curl.h>
#include "twitter.h"

#define SERVICE_UPDATE_URL           "http://twitter.com/statuses/update.json"
#define SERVICE_FRIENDS_TIMELINE_URL "http://twitter.com/statuses/friends_timeline.json"
#define SERVICE_USER_TIMELINE_URL    "http://twitter.com/statuses/user_timeline/"
#define SERVICE_PUBLIC_TIMELINE_URL  "http://twitter.com/statuses/public_timeline.json"

static char* response_data = NULL;  /* response data from server. */
static size_t response_size = 0;  /* response size of data */
static size_t handle_returned_data(char* ptr, size_t size, size_t nmemb, void* stream) {
  if (!response_data) {
    response_data = new char[size*nmemb];
  } else {
    char* response_tmp = new char[response_size+size*nmemb];
    memset(response_tmp, 0, response_size+size*nmemb);
    memcpy(response_tmp, response_data, response_size);
    delete[] response_data;
    response_data = response_tmp;
  }
  if (response_data) {
    memcpy(response_data+response_size, ptr, size*nmemb);
    response_size += size*nmemb;
  }
  return size*nmemb;
}

v8::Handle<v8::Value> TwitterUpdateStatus(const v8::Arguments& args) {
  v8::HandleScope handle_scope;
  v8::TryCatch try_catch;

  if (args.Length() != 1) return v8::ThrowException(v8::String::New("Error: usage is updateStatus(message)"));

  v8::Handle<v8::Value> ret = v8::Undefined();
  v8::Local<v8::Object> This = args.This();

  v8::String::AsciiValue username(This->Get(v8::String::New("username")));
  v8::String::AsciiValue password(This->Get(v8::String::New("password")));

  v8::Handle<v8::Object> global = v8::Context::GetCurrent()->Global();
  v8::Local<v8::Function> func = v8::Function::Cast(*global->Get(v8::String::New("encodeURIComponent")));
  v8::Local<v8::Value> funcargs[1];
  funcargs[0] = args[0]->ToString();
  v8::Local<v8::Value> result_val = func->Call(global, 1, funcargs);
  v8::String::AsciiValue escaped(result_val->ToString());
  char *status = *escaped;

  CURL* curl = NULL;
  CURLcode res = CURLE_OK;
  char *auth;
  char *url;

  response_data = NULL;
  response_size = 0;
  curl = curl_easy_init();
  if (!curl) return v8::ThrowException(v8::String::New("Error: unknown"));

  int n_url = strlen(SERVICE_UPDATE_URL) + 8 + strlen(status) + 1;
  url = new char[n_url];
  memset(url, 0, n_url);
  strcpy(url, SERVICE_UPDATE_URL);
  strcat(url, "?status=");
  strcat(url, status);

  int n_auth = strlen(*username) + 1 + strlen(*password) + 1;
  auth = new char[n_auth];
  memset(auth, 0, n_auth);
  strcpy(auth, *username);
  strcat(auth, ":");
  strcat(auth, *password);

  curl_easy_setopt(curl, CURLOPT_URL, url);
  curl_easy_setopt(curl, CURLOPT_USERPWD, auth);
  curl_easy_setopt(curl, CURLOPT_WRITEFUNCTION, handle_returned_data);
  curl_easy_setopt(curl, CURLOPT_FOLLOWLOCATION, 1);
  curl_easy_setopt(curl, CURLOPT_POST, 1);
  curl_easy_setopt(curl, CURLOPT_POSTFIELDS, "");
  res = curl_easy_perform(curl);
  int stat = 0;
  res == CURLE_OK ? curl_easy_getinfo(curl, CURLINFO_HTTP_CODE, &stat) : res;
  curl_easy_cleanup(curl);

  delete[] auth;
  delete[] url;

  if (res != CURLE_OK) {
    ret = v8::ThrowException(v8::String::New("Error: unknown"));
  }
  if (response_data) {
    delete[] response_data;
    response_data = NULL;
  }
  return ret;
}

v8::Handle<v8::Value> TwitterTimeline(const char* url, const char* username, const char* password) {
  v8::Handle<v8::Value> ret = v8::Undefined();

  CURL* curl = NULL;
  CURLcode res = CURLE_OK;
  char *auth;

  response_data = NULL;
  response_size = 0;
  curl = curl_easy_init();
  if (!curl) return v8::ThrowException(v8::String::New("Error: unknown"));

  int n_auth = strlen(username) + 1 + strlen(password) + 1;
  auth = new char[n_auth];
  memset(auth, 0, n_auth);
  strcpy(auth, username);
  strcat(auth, ":");
  strcat(auth, password);

  curl_easy_setopt(curl, CURLOPT_URL, url);

  curl_easy_setopt(curl, CURLOPT_USERPWD, auth);
  curl_easy_setopt(curl, CURLOPT_WRITEFUNCTION, handle_returned_data);
  curl_easy_setopt(curl, CURLOPT_FOLLOWLOCATION, 1);
  res = curl_easy_perform(curl);
  int stat = 0;
  res == CURLE_OK ? curl_easy_getinfo(curl, CURLINFO_HTTP_CODE, &stat) : res;
  curl_easy_cleanup(curl);

  delete[] auth;

  if (res == CURLE_OK) {
    char* json = new char[response_size+1];
    memset(json, 0, response_size+1);
    memcpy(json, (char*) response_data, response_size);
    v8::Handle<v8::String> source = v8::String::New(json);
    delete[] json;

    v8::Handle<v8::Script> script = v8::Script::Compile(source);
    if (script.IsEmpty()) {
      ret = v8::ThrowException(v8::String::New("Error: unknown"));
      goto leave;
    }
    v8::Handle<v8::Value> result = script->Run();
    if (script.IsEmpty()) {
      ret = v8::ThrowException(v8::String::New("Error: unknown"));
      goto leave;
    }
    if (!result->IsArray()) {
      ret = v8::ThrowException(v8::String::New("Error: unknown"));
      goto leave;
    }
    ret = result;
  }

leave:
  if (response_data) {
    delete[] response_data;
    response_data = NULL;
  }
  return ret;
}

v8::Handle<v8::Value> TwitterFriendsTimeline(const v8::Arguments& args) {
  v8::HandleScope handle_scope;
  v8::TryCatch try_catch;

  if (args.Length() != 0) return v8::ThrowException(v8::String::New("Error: usage is friendsTimeline()"));

  v8::Handle<v8::Value> ret = v8::Undefined();
  v8::Handle<v8::Object> This = args.This();

  v8::String::AsciiValue username(This->Get(v8::String::New("username")));
  v8::String::AsciiValue password(This->Get(v8::String::New("password")));

  return TwitterTimeline(SERVICE_FRIENDS_TIMELINE_URL, *username, *password);
}

v8::Handle<v8::Value> TwitterUserTimeline(const v8::Arguments& args) {
  v8::HandleScope handle_scope;
  v8::TryCatch try_catch;

  if (args.Length() != 1) return v8::ThrowException(v8::String::New("Error: usage is userTimeline(username)"));

  v8::Handle<v8::Value> ret = v8::Undefined();
  v8::Handle<v8::Object> This = args.This();

  v8::String::AsciiValue target(args[0]);
  v8::String::AsciiValue username(This->Get(v8::String::New("username")));
  v8::String::AsciiValue password(This->Get(v8::String::New("password")));

  int n_targeturl = strlen(SERVICE_USER_TIMELINE_URL) + strlen(*target) + 5 + 1;
  char* targeturl = new char[n_targeturl];
  memset(targeturl, 0, n_targeturl);
  strcpy(targeturl , SERVICE_USER_TIMELINE_URL);
  strcat(targeturl , *target);
  strcat(targeturl , ".json");
  ret = TwitterTimeline(targeturl, *username, *password);
  delete[] targeturl;

  return ret;
}

v8::Handle<v8::Value> TwitterPublicTimeline(const v8::Arguments& args) {
  v8::HandleScope handle_scope;
  v8::TryCatch try_catch;

  if (args.Length() != 0) return v8::ThrowException(v8::String::New("Error: usage is publicTimeline()"));

  v8::Handle<v8::Value> ret = v8::Undefined();
  v8::Handle<v8::Object> This = args.This();

  v8::String::AsciiValue username(This->Get(v8::String::New("username")));
  v8::String::AsciiValue password(This->Get(v8::String::New("password")));
  return TwitterTimeline(SERVICE_PUBLIC_TIMELINE_URL, *username, *password);
}