struct dc_entry_t* dc_entry_from_json(struct json_object* json)
{
struct dc_entry_t* entry;
struct json_object* tmp;
entry = (struct dc_entry_t*) malloc(sizeof(struct dc_entry_t));
memset(entry, 0, sizeof(struct dc_entry_t));
tmp = json_object_object_get(json, "fileName");
str_init_create(&entry->fileName, json_object_get_string(tmp), 0);
tmp = json_object_object_get(json, "fileSize");
entry->fileSize = strtol((char*)json_object_get_string(tmp), NULL, 10);
tmp = json_object_object_get(json, "uploadDate");
entry->uploadDate = strtol((char*)json_object_get_string(tmp), NULL, 10);
tmp = json_object_object_get(json, "deviceID");
str_init_create(&entry->deviceID, json_object_get_string(tmp), 0);
tmp = json_object_object_get(json, "isFolder");
entry->isFolder = strtol((char*)json_object_get_string(tmp), NULL, 10);
tmp = json_object_object_get(json, "path");
str_init_create(&entry->path, json_object_get_string(tmp), 0);
tmp = json_object_object_get(json, "_id");
str_init_create(&entry->_id, json_object_get_string(tmp), 0);
return entry;
}
void dci_get_file_list(const char *path, struct dci_state *state)
{
int is_already_path = dci_is_already_path(path, state);
if(is_already_path) return;
struct str_t uri;
str_init_create(&uri, filelist_uri, 0);
struct str_t path_param;
str_init_create(&path_param, "path=", 0);
struct str_t *path_str = str_urlencode_char(path, 0);
const struct str_t const* uri_parts[] =
{
&path_param,
path_str
};
str_concat(&uri, sizeof(uri_parts)/sizeof(const struct str_t const*), uri_parts);
{
struct request_t request;
ci_init(&request, &uri, 0, NULL, NULL, GET);
ci_request(&request);
json_parse_file_list(path, &request.response.body, state);
ci_destroy(&request);
}
str_destroy(&uri);
}
int dci_load(struct dci_state* state, struct dc_entry_t* entry)
{
if(entry->cached == 0)
{
struct str_t uri;
str_init_create(&uri, getfile_uri, 0);
const struct str_t const* uri_parts[] =
{
&slash,
&entry->_id,
};
str_concat(&uri, sizeof(uri_parts)/sizeof(const struct str_t const*), uri_parts);
{
struct request_t request;
ci_init(&request, &uri, 0, NULL, NULL, GET);
ci_request(&request);
str_swap(&request.response.body, &entry->cache);
ci_destroy(&request);
entry->cached = 1;
}
}
return 0;
}
/** Extracts the md5sum from XML containing only an <entry>.
*
* @xml struct str_t* the string containing the XML
*
* @return a string containing the extracted md5sum.
*/
struct str_t* xml_get_md5sum(const struct str_t* xml)
{
size_t length;
xmlNodePtr c1;
xmlChar *value = NULL;
struct str_t* ret = NULL;
const char* iter = strstr(xml->str, "<entry");
xmlDocPtr xmldoc = xmlParseMemory(iter, xml->len - (iter - xml->str));
xmlNodePtr node;
if(xmldoc == NULL || xmldoc->children == NULL || xmldoc->children->children == NULL)
return NULL;
for(node = xmldoc->children->children; node != NULL; node = node->next)
{
char const *name = node->name;
switch(*name)
{
case 'm':
if(strcmp(name, "md5Checksum") == 0)
{
ret = (struct str_t*) malloc(sizeof(struct str_t));
if(!ret)
break;
value = xmlNodeListGetString(xmldoc, node->children, 1);
str_init_create(ret, value, 0);
xmlFree(value);
}
break;
default:
break;
}
}
return ret;
}
int dci_init(struct dci_state *state)
{
union func_u func;
str_init_create(&plus, "+", 0);
str_init_create(&, "&", 0);
str_init_create(&que, "?", 0);
str_init_create(&slash, "/", 0);
struct stack_t *estack = (struct stack_t*)malloc(sizeof(struct stack_t));
if(!estack)
return 1;
if(fstack_init(estack, 20))
return 1;
struct stack_t *gstack = (struct stack_t*)malloc(sizeof(struct stack_t));
if(!gstack)
return 1;
if(fstack_init(gstack, 20))
return 1;
state->stack = estack;
state->head = NULL;
state->tail = NULL;
state->callback_error = 0;
state->num_files = 0;
// init the socket stuff //
if(curl_global_init(CURL_GLOBAL_SSL) != 0)
goto init_fail;
func.func2 = curl_global_cleanup;
fstack_push(estack, NULL, &func, 2);
state->curlmulti = curl_multi_init();
// if(state->curlmulti == NULL)
// goto init_fail;
// func.func3 = curl_global_cleanup;
// fstack_push(estack, state->curlmulti, &func, 3);
//dci_get_file_list("/", state);
goto init_success;
init_fail:
while(estack->size)
fstack_pop(estack);
while(gstack->size)
fstack_pop(gstack);
fstack_destroy(estack);
free(estack);
fstack_destroy(gstack);
free(gstack);
return 1;
init_success:
while(gstack->size)
fstack_pop(gstack);
fstack_destroy(gstack);
free(gstack);
return 0;
}
int dci_write(const char *path, const char *buf, size_t size, const char *fileName, struct dci_state *state)
{
struct str_t header;
struct str_t fileName_param;
struct str_t fileSize_param;
struct str_t uploadDate_param;
struct str_t deviceID_param;
struct str_t isFolder_param;
struct str_t path_param;
struct str_t data_param;
struct str_t data;
str_init_create(&header, "Content-Type: application/json", 0);
str_init_create(&fileName_param, "fileName=", 0);
str_init_create(&fileSize_param, "fileSize=", 0);
str_init_create(&uploadDate_param, "uploadDate=", 0);
str_init_create(&deviceID_param, "deviceID", 0);
str_init_create(&isFolder_param, "isFolder=", 0);
str_init_create(&path_param, "path=", 0);
str_init_create(&data_param, "data=", 0);
struct dc_entry_t* entry;
entry = (struct dc_entry_t*) malloc(sizeof(struct dc_entry_t));
memset(entry, 0, sizeof(struct dc_entry_t));
str_init_create(&entry->fileName, fileName, 0);
entry->fileSize = size;
entry->uploadDate = time(0);
str_init_create(&entry->deviceID, "binensky", 0);
entry->isFolder = 0;
str_init_create(&entry->path, path, 0);
str_init_create(&entry->cache, buf, 0);
entry->cached = 1;
struct str_t uri;
struct str_t param_uri;
str_init_create(&uri, getfile_uri, 0);
str_init(¶m_uri);
const struct str_t const* uri_parts[] =
{
&fileName_param,
fileName,
&,
&fileSize_param,
itoa(entry->fileSize),
&,
&uploadDate_param,
itoa(entry->uploadDate),
&,
&deviceID_param,
&entry->deviceID,
&,
&isFolder_param,
itoa(entry->isFolder),
&,
&path_param,
&entry->path,
&,
&data_param,
&entry->cache
};
str_concat(¶m_uri, sizeof(uri_parts)/sizeof(const struct str_t const*), uri_parts);
{
struct request_t request;
ci_init(&request, &uri, 0, NULL, param_uri.str, POST);
ci_request(&request);
str_swap(&request.response.body, &entry->_id);
ci_destroy(&request);
struct dc_entry_t *tmp = dci_last_entry(state);
tmp = entry;
}
}
/** Creates and fills in a gd_fs_entry_t from an <entry>...</entry> in xml.
*
* @xml the xml containing the entry
* @node the node representing this <entry>...</entry> block
*
* @returns pointer to gd_fs_entry_t with fields filled in as needed
*/
struct gd_fs_entry_t* gd_fs_entry_from_xml(xmlDocPtr xml, xmlNodePtr node)
{
struct gd_fs_entry_t* entry;
entry = (struct gd_fs_entry_t*) malloc(sizeof(struct gd_fs_entry_t));
if(entry == NULL) {} // TODO: ERROR
memset(entry, 0, sizeof(struct gd_fs_entry_t));
size_t length;
xmlNodePtr c1, c2;
xmlChar *value = NULL;
for(c1 = node->children; c1 != NULL; c1 = c1->next)
{
char const *name = c1->name;
switch(*name)
{
case 'a': // 'author'
for(c2 = c1->children; c2 != NULL; c2 = c2->next)
{
name = c2->name;
value = xmlNodeListGetString(xml, c2->children, 1);
switch(*name)
{
case 'n':
str_init_create(&entry->author, value, 0);
break;
case 'e':
str_init_create(&entry->author_email, value, 0);
break;
default:
break;
}
xmlFree(value);
}
break;
case 'c':
if(strcmp(name, "content") == 0)
{
value = xmlGetProp(c1, "src");
str_init_create(&entry->src, value, 0);
xmlFree(value);
}
break;
case 'f':
if(strcmp(name, "feedlink") == 0)
{
value = xmlGetProp(c1, "rel");
if(strcmp(value, "http://schemas.google.com/acl/2007#accessControlList") == 0)
{
// Link for r/w access to ACLS for this entry
// Do we care?
// Can we expose this?
}
else if(strcmp(value, "http://schemas.google.com/docs/2007/revisions") == 0)
{
// Link for r/w access to revisions
// It would be cool if we can expose these somehow
}
}
break;
case 'l':
if(strcmp(name, "lastModifiedBy") == 0)
{
for(c2 = c1->children; c2 != NULL; c2 = c2->next)
{
name = c2->name;
value = xmlNodeListGetString(xml, c2->children, 1);
switch(*name)
{
case 'n':
str_init_create(&entry->lastModifiedBy, value, 0);
break;
case 'e':
str_init_create(&entry->lastModifiedBy_email, value, 0);
break;
default:
break;
}
xmlFree(value);
}
}
else if(strcmp(name, "link") == 0)
{
value = xmlGetProp(c1, "rel");
if(strcmp(value, "http://schemas.google.com/docs/2007#parent") == 0)
{
// This entry is inside one (or more?) collections
// These entries are the folders for this entry
}
else if(strcmp(value, "alternate") == 0)
{
// Link you can open this document in a web browser with
// Do we care?
}
else if(strcmp(value, "self") == 0)
{
// Link to XML feed for just this entry
// Might be useful for checking for updates instead of changesets
xmlChar *href = xmlGetProp(c1, "href");
str_init_create(&entry->feed, href, 0);
xmlFree(href);
}
else if(strcmp(value, "edit") == 0)
{
// For writes?
}
/*
else if(strcmp(value, "edit-media") == 0)
{
// deprecated, use 'resumeable-edit-media'
}
*/
else if(strcmp(value, "http://schemas.google.com/g/2005#resumable-edit-media") == 0)
{
// For resumeable writes?
// This may be the one we *really* want to use, rather than 'edit'
}
else if(strcmp(value, "http://schemas.google.com/docs/2007/thumbnail") == 0)
{
// Might be a useful way to expose this for GUI file managers?
}
xmlFree(value);
}
break;
case 'm':
if(strcmp(name, "md5Checksum") == 0)
{
value = xmlNodeListGetString(xml, c1->children, 1);
entry->md5set = 1;
str_init_create(&entry->md5, value, 0);
xmlFree(value);
}
break;
case 't': // 'title'
if(strcmp(name, "title") == 0)
{
value = xmlNodeListGetString(xml, c1->children, 1);
str_init_create(&entry->filename, value, 0);
entry->filename.str = filenameencode(value, &entry->filename.len);
entry->filename.reserved = entry->filename.len;
xmlFree(value);
}
break;
case 's':
if(strcmp(name, "size") == 0)
{
value = xmlNodeListGetString(xml, c1->children, 1);
length = xmlStrlen(value);
// TODO: errors?
entry->size = strtol((char*)value, NULL, 10);
xmlFree(value);
}
break;
default:
break;
}
}
return entry;
}
