Пример #1
0
/*----------------------------------------------------------------------
|       Listener_OnPropertyChanged
+---------------------------------------------------------------------*/
static void
Listener_OnPropertyChanged(ATX_PropertyListener*    _self,
                           ATX_CString              name,
                           ATX_PropertyType         type,
                           const ATX_PropertyValue* value)
{
    Listener* self = ATX_SELF(Listener, ATX_PropertyListener);

    ATX_Debug("OnPropertyChanged[%s]: ", ATX_CSTR(self->name));
    if (value) {
        PrintProperty(name, type, value);
    } else {
        ATX_Debug("name=%s [REMOVED]\n", name);
    }
}
Пример #2
0
/*----------------------------------------------------------------------
|    BtController::OnAckNotification
+---------------------------------------------------------------------*/
void
BtController::OnNackNotification(BLT_DecoderServer_Message::CommandId id,
                             BLT_Result                           result)
{
    ATX_Debug("BLT_Player::OnNackNotification (id=%d, result=%d:%s)\n", 
              id, result, BLT_ResultText(result));    
}
Пример #3
0
/*----------------------------------------------------------------------
|       PrintProperty
+---------------------------------------------------------------------*/
static void
PrintProperty(ATX_CString name, ATX_PropertyType type, const ATX_PropertyValue* value)
{
    ATX_Debug("name=%s ", name);
    switch (type) {
      case ATX_PROPERTY_TYPE_INTEGER:
        ATX_Debug("[INTEGER] %d (%x)\n", value->integer, value->integer);
        break;

      case ATX_PROPERTY_TYPE_FLOAT:
        ATX_Debug("[FLOAT] %f\n", value->fp);
        break;

      case ATX_PROPERTY_TYPE_BOOLEAN:
        ATX_Debug("[BOOL] %s\n", 
                  value->boolean == ATX_TRUE ? "TRUE" : "FALSE");
        break;

      case ATX_PROPERTY_TYPE_STRING:
        ATX_Debug("[STRING] %s\n", value->string);
        break;

      case ATX_PROPERTY_TYPE_RAW_DATA:
        ATX_Debug("[DATA] %d bytes at %lx\n", 
                  value->raw_data.size, ATX_POINTER_TO_LONG(value->raw_data.data));
        break;

      default:
        ATX_Debug("[UNKNOWN]\n");
        break;
    }
}
Пример #4
0
/*----------------------------------------------------------------------
|       DumpProperties
+---------------------------------------------------------------------*/
static void
DumpProperties(ATX_Properties* properties)
{
    ATX_Iterator* iterator;
    ATX_Property* property;

    ATX_Debug("[PROPERTIES] -------------------------------\n");
    if (ATX_FAILED(ATX_Properties_GetIterator(properties, &iterator))) {
        return;
    }
    while (ATX_SUCCEEDED(ATX_Iterator_GetNext(iterator, 
                                              (ATX_Any*)(void*)&property))) {
        PrintProperty(property->name, property->type, &property->value);
    }
    ATX_Debug("--------------------------------------------\n");

    ATX_DESTROY_OBJECT(iterator);
}
Пример #5
0
/*----------------------------------------------------------------------
|       main
+---------------------------------------------------------------------*/
int 
main(int argc, char** argv)
{
    ATX_HttpClient*   client;
    ATX_HttpRequest*  request;
    ATX_HttpResponse* response;
    ATX_InputStream*  response_body = NULL;
    ATX_Size          response_body_size = 0;
    ATX_Result        result;

    /* create a request */
    result = ATX_HttpRequest_Create(ATX_HTTP_METHOD_GET, "http://zebulon.bok.net/tmp/redirect", &request);
    CHECK_RESULT(result, "ATX_HttpRequest_Create failed");
    
    /* create a client */
    result = ATX_HttpClient_Create(&client);
    CHECK_RESULT(result, "ATX_HttpClient_Create failed");

    /* send the request and get a response */
    result = ATX_HttpClient_SendRequest(client, request, &response);
    CHECK_RESULT(result, "ATX_HttpClient_SendRequest failed");

    /* print the response */
    ATX_Debug("StatusCode = %d\n", ATX_HttpResponse_GetStatusCode(response));
    ATX_Debug("ResonPhrase = %s\n", 
              ATX_String_GetChars(ATX_HttpResponse_GetReasonPhrase(response)));
    ATX_HttpMessage_GetBody((const ATX_HttpMessage*)response, NULL, &response_body_size);
    ATX_Debug("BodySize = %d\n", response_body_size);


    /* cleanup */
    ATX_RELEASE_OBJECT(response_body);
    ATX_HttpResponse_Destroy(response);
    ATX_HttpRequest_Destroy(request);
    ATX_HttpClient_Destroy(client);

    return 0;
}
Пример #6
0
/*----------------------------------------------------------------------
|   ATX_HttpClient_SendRequest
+---------------------------------------------------------------------*/
ATX_Result
ATX_HttpClient_SendRequest(ATX_HttpClient*    self, 
                           ATX_HttpRequest*   request, 
                           ATX_HttpResponse** response)
{
    ATX_Cardinal watchdog = ATX_HTTP_MAX_REDIRECTS;
    ATX_Boolean  keep_going;
    ATX_Result   result;

    do {
        keep_going = ATX_FALSE;
        result = ATX_HttpClient_SendRequestOnce(self, request, response);
        if (ATX_FAILED(result)) break;
        if (*response && 
            self->options.follow_redirect &&
            ((*response)->status_code == 301 ||
             (*response)->status_code == 302 ||
             (*response)->status_code == 303 ||
             (*response)->status_code == 307)) {
            /* handle redirect */
            const ATX_String* location = 
                ATX_HttpMessage_GetHeader((ATX_HttpMessage*)*response,
                                          ATX_HTTP_HEADER_LOCATION);
            if (location) {
                /* replace the request url */
                ATX_HttpUrl url;
                result = ATX_HttpUrl_Construct(&url, ATX_String_GetChars(location));
                if (ATX_SUCCEEDED(result)) {
                    ATX_HttpUrl_Destruct(&request->url);
                    request->url = url;
                    keep_going = ATX_TRUE;

                    ATX_Debug("ATX_HttpClient::SendRequest - redirecting to %s\n",
                              ATX_String_GetChars(location));
                }
            }
        }       
    } while (keep_going && watchdog--);

    return result;
}
Пример #7
0
/*----------------------------------------------------------------------
|    ATX_HttpMessage_Emit
+---------------------------------------------------------------------*/
ATX_Result
ATX_HttpMessage_Emit(const ATX_HttpMessage* message, ATX_OutputStream* stream)
{
    ATX_ListItem* item = ATX_List_GetFirstItem(message->headers);

    /* output the headers */
    while (item) {
        ATX_HttpHeader* header = ATX_ListItem_GetData(item);
        if (header && 
            !ATX_String_IsEmpty(&header->name) && 
            !ATX_String_IsEmpty(&header->value)) {
            ATX_OutputStream_WriteString(stream, ATX_CSTR(header->name));
            ATX_OutputStream_Write(stream, ": ", 2, NULL);
            ATX_OutputStream_WriteLine(stream, ATX_CSTR(header->value));
            ATX_Debug("ATX_HttpMessage::Emit - %s: %s\n", ATX_CSTR(header->name), ATX_CSTR(header->value));
        }
        item = ATX_ListItem_GetNext(item);
    }

    return ATX_SUCCESS;
}
Пример #8
0
/*----------------------------------------------------------------------
|       ConnectClient
+---------------------------------------------------------------------*/
static ATX_Result
ConnectClient(ATX_ClientSocket* client, 
              char*             hostname, 
              ATX_SocketPort    port,
              ATX_ByteStream*   stream)
{
    ATX_Socket socket;
    ATX_Result result;
    
    ATX_Debug("connecting to %s on port %d\n", hostname, port);

    /* connect client */
    result = ATX_ClientSocket_Connect(client, hostname, port, 10000);
    if (result != ATX_SUCCESS) {
        ATX_Debug("ERROR: connection failed (%d)\n", result);
        return result;
    }
    ATX_Debug("connected\n");

    /* cast to ATX_Socket interface */
    result = ATX_CAST_OBJECT(client, &socket, ATX_Socket);
    if (result != ATX_SUCCESS) {
        ATX_Debug("ERROR: client object does not implement the "
                  "ATX_Socket interface\n");
        return result;
    }

    /* get socket stream */
    result = ATX_Socket_GetStream(&socket, stream);
    if (result != ATX_SUCCESS) {
        ATX_Debug("ERROR: cannot get socket stream\n");
        return result;
    }

    /* check stream */
    if (ATX_OBJECT_IS_NULL(stream)) {
        ATX_Debug("ERROR: stream is NULL\n");
        return ATX_FAILURE;
    }

    return ATX_SUCCESS;
}
Пример #9
0
/*----------------------------------------------------------------------
|    ATX_HttpResponse_Parse
+---------------------------------------------------------------------*/
static ATX_Result 
ATX_HttpResponse_Parse(ATX_HttpResponse* response, ATX_InputStream* stream)
{
    char        buffer[ATX_HTTP_MAX_LINE_SIZE+1];
    char*       line = buffer;
    char*       find;
    ATX_Boolean header_pending = ATX_FALSE;
    ATX_String  header_name = ATX_EMPTY_STRING;
    ATX_String  header_value = ATX_EMPTY_STRING;
    ATX_Result  result;

    /* get the first line from the stream */
    result = ATX_InputStream_ReadLine(stream, line, sizeof(buffer), NULL);
    if (ATX_FAILED(result)) return result;

    /* get the protocol */
    find = (char*)ATX_Http_FindChar(line, ' ');
    if (find == NULL) {
        return ATX_ERROR_INVALID_SYNTAX;
    }
    *find = '\0';
    ATX_String_Assign(&response->base.protocol, line);

    /* get the status code */
    line = (char*)ATX_Http_SkipWhitespace(find+1);
    find = (char*)ATX_Http_FindChar(line, ' ');
    if (find == NULL) {
        return ATX_ERROR_INVALID_SYNTAX;
    }
    *find = '\0';
    if (ATX_StringLength(line) != 3) {
        return ATX_ERROR_INVALID_SYNTAX;
    }
    {
        int i;
        response->status_code = 0;
        for (i=0; i<3; i++) {
            if (line[i] < '0' || line[i] > '9') {
                return ATX_ERROR_INVALID_SYNTAX;
            }
            response->status_code *= 10;
            response->status_code += line[i]-'0';
        }
    }

    /* the rest is the reason phrase */
    line = (char*)ATX_Http_SkipWhitespace(find+1);
    ATX_String_Assign(&response->reason_phrase, line);

    /* parse headers until an empty line or end of stream */
    do {
        /* read a line */
        result = ATX_InputStream_ReadLine(stream, line, sizeof(buffer), NULL);
        if (ATX_FAILED(result)) break;

        /* stop if line is empty */
        if (line[0] == '\0' || line[0] == '\r' || line[0] == '\n') {
            if (header_pending) {
                ATX_String_TrimWhitespace(&header_value);
                ATX_HttpMessage_SetHeader((ATX_HttpMessage*)response, 
                                          ATX_CSTR(header_name), 
                                          ATX_CSTR(header_value));
                ATX_Debug("ATX_HttpResponse::Parse - %s: %s\n",
                          ATX_CSTR(header_name),
                          ATX_CSTR(header_value));
            }
            break;
        }

        /* process the line */
        if ((line[0] == ' ' || line[0] == '\t') && header_pending) {
            /* this is a line continuation */
            ATX_String_Append(&header_value, line+1);
        } else {
            /* this is a new header */
            const char* name;
            const char* value;

            /* add the pending header to the list */
            if (header_pending) {
                ATX_String_TrimWhitespace(&header_value);
                ATX_HttpMessage_SetHeader((ATX_HttpMessage*)response, 
                                          ATX_CSTR(header_name), 
                                          ATX_CSTR(header_value));
                ATX_Debug("ATX_HttpResponse::Parse - %s: %s\n",
                           ATX_CSTR(header_name),
                           ATX_CSTR(header_value));
            }

            /* parse header name */
            name = ATX_Http_SkipWhitespace(line);
            value = ATX_Http_FindChar(name, ':');
            ATX_String_AssignN(&header_name, name, (ATX_Size)(value-name));
            value = ATX_Http_SkipWhitespace(value+1);
            ATX_String_Assign(&header_value, value);

            /* don't add the header now, it could be continued */
            header_pending = ATX_TRUE;
        }
    } while(ATX_SUCCEEDED(result));

    /* keep a reference to the stream */
    response->base.body = stream;
    ATX_REFERENCE_OBJECT(stream);

    /* cleanup */
    ATX_String_Destruct(&header_name);
    ATX_String_Destruct(&header_value);

    return ATX_SUCCESS;
}
Пример #10
0
/*----------------------------------------------------------------------
|   ATX_HttpClient_SendRequestOnce
+---------------------------------------------------------------------*/
static ATX_Result
ATX_HttpClient_SendRequestOnce(ATX_HttpClient*    self, 
                               ATX_HttpRequest*   request, 
                               ATX_HttpResponse** response)

{
    ATX_Socket*       connection = NULL;
    ATX_SocketAddress address;
    ATX_InputStream*  input_stream = NULL;
    ATX_OutputStream* output_stream = NULL;
    ATX_Result        result;

    /* set default return value */
    *response = NULL;

    /* resolve the host address */
    ATX_Debug("ATX_HttpClient::SendRequest - resolving name [%s]...\n",
              ATX_CSTR(request->url.host));
    result = ATX_IpAddress_ResolveName(&address.ip_address, 
                                       ATX_CSTR(request->url.host),
                                       ATX_HTTP_RESOLVER_TIMEOUT);
    if (ATX_FAILED(result)) return result;
    address.port = request->url.port;
    ATX_Debug("ATX_HttpClient::SendRequest - name resolved\n");

    /* setup some headers */
    ATX_HttpMessage_SetHeader((ATX_HttpMessage*)request,
                              ATX_HTTP_HEADER_CONNECTION,
                              "close");
    ATX_HttpMessage_SetHeader((ATX_HttpMessage*)request,
                              ATX_HTTP_HEADER_HOST,
                              ATX_CSTR(request->url.host));
    ATX_HttpMessage_SetHeader((ATX_HttpMessage*)request,
                              ATX_HTTP_HEADER_USER_AGENT,
                              ATX_HTTP_HEADER_DEFAULT_AGENT);

    /* create a socket to connect to the server */
    result = ATX_TcpClientSocket_Create(&connection);
    if (ATX_FAILED(result)) return result;

    /* connect to the server */
    ATX_Debug("ATX_HttpClient::SendRequest - connecting on port %d...\n",
               request->url.port);
    result = ATX_Socket_Connect(connection, &address, ATX_HTTP_CONNECT_TIMEOUT);
    if (ATX_FAILED(result)) goto end;

    /* emit the request onto the connection */
    result = ATX_Socket_GetOutputStream(connection, &output_stream);
    if (ATX_FAILED(result)) goto end;
    result = ATX_HttpRequest_Emit(request, output_stream);
    if (ATX_FAILED(result)) goto end;

    /* create a response from the connection's input stream */
    result = ATX_Socket_GetInputStream(connection, &input_stream);
    if (ATX_FAILED(result)) goto end;
    result = ATX_HttpResponse_CreateFromStream(input_stream, response);
    if (ATX_FAILED(result)) goto end;

end:
    if (ATX_FAILED(result)) {
        if (*response != NULL) {
            ATX_HttpResponse_Destroy(*response);
        }
    }
    ATX_RELEASE_OBJECT(input_stream);
    ATX_RELEASE_OBJECT(output_stream);
    ATX_DESTROY_OBJECT(connection);
    return result;
}
Пример #11
0
/*----------------------------------------------------------------------
|    BtController::OnAckNotification
+---------------------------------------------------------------------*/
void
BtController::OnAckNotification(BLT_DecoderServer_Message::CommandId id)
{
    ATX_Debug("BLT_Player::OnAckNotification (id=%d)\n", id);
}
Пример #12
0
/*----------------------------------------------------------------------
|       main
+---------------------------------------------------------------------*/
int 
main(int argc, char** argv)
{
    ATX_Properties*            properties;
    ATX_PropertyListener*      listener0;
    ATX_PropertyListenerHandle listener0_handle = NULL;
    ATX_PropertyListener*      listener1;
    ATX_PropertyListenerHandle listener1_handle = NULL;
    ATX_PropertyListener*      listener2;
    ATX_PropertyListenerHandle listener2_handle = NULL;
    unsigned int               i;
    unsigned int               j;
    ATX_Result                 result;

    ATX_COMPILER_UNUSED(argc);
    ATX_COMPILER_UNUSED(argv);

    ATX_Debug("PropertiesTest -- Start\n");
    Listener_Create("Listener 0", &listener0);
    Listener_Create("Listener 1", &listener1);
    Listener_Create("Listener 2", &listener2);

    result = ATX_Properties_Create(&properties);

    Properties[2].value.fp = 0.123456789f;

    j = 0;
    for (i=0; i<10000; i++) {
        DumpProperties(properties);
        if (rand()&0x4) {
            ATX_Debug("** setting property '%s' [%d]\n", 
                      Properties[j].name, j);
            result = ATX_Properties_SetProperty(properties, 
                                                Properties[j].name,
                                                Properties[j].type,
                                                &Properties[j].value);
            ATX_Debug("(%d)\n", result);
        } else {
            ATX_Debug("&& unsetting property '%s' [%d]\n", 
                      Properties[j].name, j);
            result = ATX_Properties_UnsetProperty(properties,
                                                  Properties[j].name);
            ATX_Debug("(%d)\n", result);
        }
        j++;
        if (j >= sizeof(Properties)/sizeof(Properties[0])) {
            j = 0;
        }
        if (rand()%7 == 0) {
            int l = rand()%3;
            ATX_PropertyListener* listener;
            ATX_PropertyListenerHandle* listener_handle;
            if (l == 0) {
                listener = listener0;
                listener_handle = &listener0_handle;
            } else if (l == 1) {
                listener = listener1;
                listener_handle = &listener1_handle;
            } else {
                listener = listener2;
                listener_handle = &listener2_handle;
            }
            if (*listener_handle) {
                result = ATX_Properties_RemoveListener(properties, 
                                                       *listener_handle);
                ATX_Debug("## removed listener %d [%d]\n", 
                          l, result);
            }
            result = ATX_Properties_AddListener(properties, 
                                                Properties[j].name,
                                                listener,
                                                listener_handle);
            ATX_Debug("## added listener %d on %s [%d]\n", 
                      l, Properties[j].name, result);
        }
        ATX_Debug("++++++++++++++++++++++++++++++++++++++++++++\n");
    }

    ATX_DESTROY_OBJECT(properties);
    ATX_DESTROY_OBJECT(listener0);
    ATX_DESTROY_OBJECT(listener1);
    ATX_DESTROY_OBJECT(listener2);

    ATX_Debug("PropertiesTest -- End\n");

    return 0;
}