prowl.c

Go to the documentation of this file.

/*
 * ----------------------------------------------------------------------------
 * "THE BEER-WARE LICENSE" (Revision 42):
 * <abort@digitalise.net> wrote this file. As long as you retain this notice you
 * can do whatever you want with this stuff. If we meet some day, and you think
 * this stuff is worth it, you can buy me a beer in return J. Dijkstra (04/29/2010)
 * ----------------------------------------------------------------------------
 */
#include "prowl.h"


static int prowl_get_response_code(char* response);
static prowl_connection* prowl_ssl_connect();
static SOCKET prowl_tcp_connect();
static char* prowl_ssl_read(prowl_connection* c);
static void prowl_ssl_disconnect(prowl_connection* c);
static char prowl_int_to_hex(char code);
static char* prowl_url_encode(char* str);

int prowl_push_msg(char* api_key, int priority, char* application_name, char* event_name, char* description)
{
  prowl_connection* c;
  char buffer[MESSAGESIZE];
  char* response = NULL;
#ifdef _WINDOWS
  static int wsa_init = 0;
#endif
  
  application_name = prowl_url_encode(application_name);
  event_name = prowl_url_encode(event_name);
  description = prowl_url_encode(description);
  
#ifdef _WINDOWS
  if (wsa_init == 0)
  {
    WSAData wsad;
    
    if (WSAStartup(MAKEWORD(2, 2), &wsad) != 0)
    {
      fprintf(stderr, "Failed to initialize winsock (%d)\n", GetLastError());
      goto end;
    }
    
#ifdef _DEBUG
    printf("Prowl [debug]: Initialized Winsock\n");
#endif
    
    wsa_init = 1;
  }
#endif
  
  
  if ((c = prowl_ssl_connect()) == NULL) goto end;
  
#ifdef _DEBUG
  printf("Prowl [debug]: Connected\n");
#endif
  
  sprintf(buffer, "GET /publicapi/add?apikey=%s&priority=%d&application=%s&event=%s&description=%s\r\nHost: %s\r\n\r\n",
      api_key, priority, application_name, event_name, description, HOSTNAME);
  if (SSL_write(c->ssl_handle, buffer, strlen(buffer)) <= 0)
  {
    fprintf(stderr, "Failed to write buffer to SSL connection\n");
    ERR_print_errors_fp(stderr);
    goto end;
  }
  
#ifdef _DEBUG
  printf("Prowl [debug]: Written buffer: %s\n", buffer);
#endif
  
  response = prowl_ssl_read(c);
  
#ifdef _DEBUG
  OutputDebugString("Prowl [debug]: server response:");
  if (response != NULL) printf("%s\n", response);
#endif
  
  prowl_ssl_disconnect(c);
  
end:
  free(application_name);
  free(event_name);
  free(description);
  
  return (response == NULL ? -1 : prowl_get_response_code(response));
}

static int prowl_get_response_code(char* response)
{
  int code;
  char* start = strstr(response, "<prowl>");
  
  /* invalid response */
  if (start == NULL) return -1; 
  
  start = strstr(start, "code");
  
  /* invalid response */
  if (start == NULL) return -1;
  
  /* failed to parse code */
  if (sscanf(start, "code=\"%d\"", &code) != 1) return -1;
  
  free(response);
  
  return code;
}

static prowl_connection* prowl_ssl_connect()
{
  prowl_connection* c = (prowl_connection*)malloc(sizeof(prowl_connection));
  
  c->socket = prowl_tcp_connect();
  if (c->socket != SOCKET_ERROR)
  {
    SSL_library_init();
    SSL_load_error_strings();
    
    c->ssl_context = SSL_CTX_new(SSLv23_client_method());
    if (c->ssl_context == NULL) ERR_print_errors_fp(stderr);
    
    c->ssl_handle = SSL_new(c->ssl_context);
    if (c->ssl_handle == NULL) ERR_print_errors_fp(stderr);
    
    SSL_CTX_set_verify(c->ssl_context, SSL_VERIFY_PEER, SSL_VERIFY_NONE);
    
    if (!SSL_set_fd(c->ssl_handle, c->socket)) ERR_print_errors_fp(stderr);
    
    if (SSL_connect(c->ssl_handle) != 1) ERR_print_errors_fp(stderr);
    
#ifdef _DEBUG
    printf("Prowl [debug]: SSL Handshake successful\n");
#endif
  }
  else
  {
#ifdef _WINDOWS
    fprintf(stderr, "Failed to retrieve a valid connected socket\n");
    return NULL;
#else
    perror("Prowl: Failed to retrieve connected socket");
#endif
  }
  
  return c;
}

static SOCKET prowl_tcp_connect()
{
  SOCKET s = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
  struct sockaddr_in server;
  struct hostent* host = gethostbyname(HOSTNAME);
  
  if (s == SOCKET_ERROR)
  {
#ifdef _WINDOWS
    fprintf(stderr, "Could not create socket (%d)\n", WSAGetLastError());
    return NULL;
#else
    perror("Prowl: Could not create socket");
#endif
  }
  
  if (host == NULL)
  {
#ifdef _WINDOWS   
    fprintf(stderr, "Could not retrieve host by name (%d)\n", WSAGetLastError());
    return NULL;
#else
    perror("Prowl: Could not retrieve host by name");
#endif
  }
  
  memset(&server, 0, sizeof(struct sockaddr_in));
  server.sin_family = AF_INET;
  server.sin_port = htons(SSL_PORT);
  server.sin_addr = *(struct in_addr*)host->h_addr_list[0];
  
  if (connect(s, (struct sockaddr*)&server, sizeof(server)) == SOCKET_ERROR)
  {
#ifdef _WINDOWS
    fprintf(stderr, "Prowl connect error (%d)\n", WSAGetLastError());
    return NULL;
#else
    perror("Prowl: connect error");
#endif
  }
  
  return s;
}

static char* prowl_ssl_read(prowl_connection* c)
{
  int r = 1;
  char buffer[BUFFERSIZE];
  int size = BUFFERSIZE + 1;
  char* retval = (char*)malloc(size);
  
  memset(retval, 0, size);
  
  while (r > 0)
  {
    r = SSL_read(c->ssl_handle, buffer, BUFFERSIZE);
    if (r > 0)
    {
      buffer[r] = '\0';
      
      retval = realloc(retval, size + r);
      strcat(retval, buffer);
    }
  }
  
  return retval;
}

static void prowl_ssl_disconnect(prowl_connection* c)
{
  if (c->socket) closesocket(c->socket);
  if (c->ssl_handle)
  {
    SSL_shutdown(c->ssl_handle);
    SSL_free(c->ssl_handle);
  }
  if (c->ssl_context) SSL_CTX_free(c->ssl_context);
  
  free(c);
}

static char prowl_int_to_hex(char code) 
{
  static char hex[] = "0123456789abcdef";
  return hex[code & 15];
}

static char* prowl_url_encode(char* str) 
{
  char* pstr = str;
  char* buf = (char*)malloc(strlen(str) * 3 + 1);
  char* pbuf = buf;
  
  while (*pstr)
  {
    if (isalnum(*pstr) || *pstr == '-' || *pstr == '_' || *pstr == '.' || *pstr == '~') 
    {
      *pbuf++ = *pstr;
    }
    else
    {
      *pbuf++ = '%';
      *pbuf++ = prowl_int_to_hex(*pstr >> 4);
      *pbuf++ = prowl_int_to_hex(*pstr & 15);
    }
    
    pstr++;
  }
  *pbuf = '\0';
  
  return buf;
}