Commit 2b05e48c authored by Matt Colyer's avatar Matt Colyer

Enforce a modified kr style.

Use "make indent" from now on before committing.
parent 7ac3d681
......@@ -3,3 +3,6 @@ SUBDIRS = src
doc:
doxygen doxygen.cfg
indent:
indent -kr -ut -ts4 -l120 src/*.c src/*.h
......@@ -33,8 +33,10 @@ extern int debug;
*
* @param client The AFC client connection to lock
*/
static void afc_lock(iphone_afc_client_t client) {
if (debug) fprintf(stderr, "Locked\n");
static void afc_lock(iphone_afc_client_t client)
{
if (debug)
fprintf(stderr, "Locked\n");
while (client->lock) {
usleep(500); // they say it's obsolete, but whatever
}
......@@ -45,8 +47,10 @@ static void afc_lock(iphone_afc_client_t client) {
*
* @param client The AFC
*/
static void afc_unlock(iphone_afc_client_t client) { // just to be pretty
if (debug) fprintf(stderr, "Unlocked\n");
static void afc_unlock(iphone_afc_client_t client)
{ // just to be pretty
if (debug)
fprintf(stderr, "Unlocked\n");
client->lock = 0;
}
......@@ -58,22 +62,23 @@ static void afc_unlock(iphone_afc_client_t client) { // just to be pretty
*
* @return A handle to the newly-connected client or NULL upon error.
*/
iphone_error_t iphone_afc_new_client ( iphone_device_t device, int src_port, int dst_port, iphone_afc_client_t *client ) {
iphone_error_t iphone_afc_new_client(iphone_device_t device, int src_port, int dst_port, iphone_afc_client_t * client)
{
int ret = IPHONE_E_SUCCESS;
iphone_afc_client_t client_loc = (iphone_afc_client_t)malloc(sizeof(struct iphone_afc_client_int));
iphone_afc_client_t client_loc = (iphone_afc_client_t) malloc(sizeof(struct iphone_afc_client_int));
if (!device) return IPHONE_E_INVALID_ARG;
if (!device)
return IPHONE_E_INVALID_ARG;
// Attempt connection
client_loc->connection = NULL;
ret = iphone_mux_new_client(device, src_port, dst_port,&client_loc->connection);
ret = iphone_mux_new_client(device, src_port, dst_port, &client_loc->connection);
if (IPHONE_E_SUCCESS != ret || !client_loc->connection) {
free(client_loc);
return ret;
}
// Allocate a packet
client_loc->afc_packet = (AFCPacket*)malloc(sizeof(AFCPacket));
client_loc->afc_packet = (AFCPacket *) malloc(sizeof(AFCPacket));
if (!client_loc->afc_packet) {
iphone_mux_free_client(client_loc->connection);
free(client_loc);
......@@ -100,7 +105,8 @@ iphone_error_t iphone_afc_new_client ( iphone_device_t device, int src_port, int
*
* @param client The client to disconnect.
*/
iphone_error_t iphone_afc_free_client ( iphone_afc_client_t client ) {
iphone_error_t iphone_afc_free_client(iphone_afc_client_t client)
{
if (!client || !client->connection || !client->afc_packet)
return IPHONE_E_INVALID_ARG;
......@@ -124,41 +130,46 @@ iphone_error_t iphone_afc_free_client ( iphone_afc_client_t client ) {
* reason is that if you set them to different values, it indicates
* you want to send the data as two packets.
*/
static int dispatch_AFC_packet(iphone_afc_client_t client, const char *data, int length) {
static int dispatch_AFC_packet(iphone_afc_client_t client, const char *data, int length)
{
int bytes = 0, offset = 0;
char *buffer;
if (!client || !client->connection || !client->afc_packet) return 0;
if (!data || !length) length = 0;
if (!client || !client->connection || !client->afc_packet)
return 0;
if (!data || !length)
length = 0;
client->afc_packet->packet_num++;
if (!client->afc_packet->entire_length) {
client->afc_packet->entire_length = (length) ? sizeof(AFCPacket) + length + 1 : sizeof(AFCPacket);
client->afc_packet->this_length = client->afc_packet->entire_length;
}
if (!client->afc_packet->this_length){
if (!client->afc_packet->this_length) {
client->afc_packet->this_length = sizeof(AFCPacket);
}
// We want to send two segments; buffer+sizeof(AFCPacket) to this_length is the parameters
// We want to send two segments; buffer+sizeof(AFCPacket) to
// this_length is the parameters
// And everything beyond that is the next packet. (for writing)
if (client->afc_packet->this_length != client->afc_packet->entire_length) {
buffer = (char*)malloc(client->afc_packet->this_length);
memcpy(buffer, (char*)client->afc_packet, sizeof(AFCPacket));
buffer = (char *) malloc(client->afc_packet->this_length);
memcpy(buffer, (char *) client->afc_packet, sizeof(AFCPacket));
offset = client->afc_packet->this_length - sizeof(AFCPacket);
if (debug) fprintf(stderr, "dispatch_AFC_packet: Offset: %i\n", offset);
if (debug)
fprintf(stderr, "dispatch_AFC_packet: Offset: %i\n", offset);
if ((length) < (client->afc_packet->entire_length - client->afc_packet->this_length)) {
if (debug){
if (debug) {
fprintf(stderr, "dispatch_AFC_packet: Length did not resemble what it was supposed");
fprintf(stderr, "to based on the packet.\n");
fprintf(stderr, "length minus offset: %i\n", length-offset);
fprintf(stderr, "rest of packet: %i\n", client->afc_packet->entire_length - client->afc_packet->this_length);
fprintf(stderr, "length minus offset: %i\n", length - offset);
fprintf(stderr, "rest of packet: %i\n",
client->afc_packet->entire_length - client->afc_packet->this_length);
}
free(buffer);
return -1;
}
memcpy(buffer+sizeof(AFCPacket), data, offset);
memcpy(buffer + sizeof(AFCPacket), data, offset);
iphone_mux_send(client->connection, buffer, client->afc_packet->this_length, &bytes);
free(buffer);
if (bytes <= 0) {
......@@ -167,22 +178,30 @@ static int dispatch_AFC_packet(iphone_afc_client_t client, const char *data, int
if (debug) {
fprintf(stderr, "dispatch_AFC_packet: sent the first now go with the second\n");
fprintf(stderr, "Length: %i\n", length-offset);
fprintf(stderr, "Length: %i\n", length - offset);
fprintf(stderr, "Buffer: \n");
fwrite(data+offset, 1, length-offset, stdout);
fwrite(data + offset, 1, length - offset, stdout);
}
iphone_mux_send(client->connection, data+offset, length-offset, &bytes);
iphone_mux_send(client->connection, data + offset, length - offset, &bytes);
return bytes;
} else {
if (debug) fprintf(stderr, "dispatch_AFC_packet doin things the old way\n");
char *buffer = (char*)malloc(sizeof(char) * client->afc_packet->this_length);
if (debug) fprintf(stderr, "dispatch_AFC_packet packet length = %i\n", client->afc_packet->this_length);
memcpy(buffer, (char*)client->afc_packet, sizeof(AFCPacket));
if (debug) fprintf(stderr, "dispatch_AFC_packet packet data follows\n");
if (length > 0) { memcpy(buffer+sizeof(AFCPacket), data, length); buffer[sizeof(AFCPacket)+length] = '\0'; }
if (debug) fwrite(buffer, 1, client->afc_packet->this_length, stdout);
if (debug) fprintf(stderr, "\n");
if (debug)
fprintf(stderr, "dispatch_AFC_packet doin things the old way\n");
char *buffer = (char *) malloc(sizeof(char) * client->afc_packet->this_length);
if (debug)
fprintf(stderr, "dispatch_AFC_packet packet length = %i\n", client->afc_packet->this_length);
memcpy(buffer, (char *) client->afc_packet, sizeof(AFCPacket));
if (debug)
fprintf(stderr, "dispatch_AFC_packet packet data follows\n");
if (length > 0) {
memcpy(buffer + sizeof(AFCPacket), data, length);
buffer[sizeof(AFCPacket) + length] = '\0';
}
if (debug)
fwrite(buffer, 1, client->afc_packet->this_length, stdout);
if (debug)
fprintf(stderr, "\n");
iphone_mux_send(client->connection, buffer, client->afc_packet->this_length, &bytes);
if (buffer) {
......@@ -205,11 +224,12 @@ static int dispatch_AFC_packet(iphone_afc_client_t client, const char *data, int
* AFC_ERROR operation)
*/
static int receive_AFC_data(iphone_afc_client_t client, char **dump_here) {
static int receive_AFC_data(iphone_afc_client_t client, char **dump_here)
{
AFCPacket *r_packet;
char *buffer = (char*)malloc(sizeof(AFCPacket) * 4);
char *buffer = (char *) malloc(sizeof(AFCPacket) * 4);
char *final_buffer = NULL;
int bytes = 0, recv_len = 0, current_count=0;
int bytes = 0, recv_len = 0, current_count = 0;
int retval = 0;
iphone_mux_recv(client->connection, buffer, sizeof(AFCPacket) * 4, &bytes);
......@@ -220,12 +240,13 @@ static int receive_AFC_data(iphone_afc_client_t client, char **dump_here) {
return -1;
}
r_packet = (AFCPacket*)malloc(sizeof(AFCPacket));
r_packet = (AFCPacket *) malloc(sizeof(AFCPacket));
memcpy(r_packet, buffer, sizeof(AFCPacket));
if (r_packet->entire_length == r_packet->this_length && r_packet->entire_length > sizeof(AFCPacket) && r_packet->operation != AFC_ERROR) {
*dump_here = (char*)malloc(sizeof(char) * (r_packet->entire_length-sizeof(AFCPacket)));
memcpy(*dump_here, buffer+sizeof(AFCPacket), r_packet->entire_length-sizeof(AFCPacket));
if (r_packet->entire_length == r_packet->this_length
&& r_packet->entire_length > sizeof(AFCPacket) && r_packet->operation != AFC_ERROR) {
*dump_here = (char *) malloc(sizeof(char) * (r_packet->entire_length - sizeof(AFCPacket)));
memcpy(*dump_here, buffer + sizeof(AFCPacket), r_packet->entire_length - sizeof(AFCPacket));
retval = r_packet->entire_length - sizeof(AFCPacket);
free(buffer);
free(r_packet);
......@@ -236,53 +257,65 @@ static int receive_AFC_data(iphone_afc_client_t client, char **dump_here) {
free(buffer);
if (r_packet->operation == AFC_ERROR && !(client->afc_packet->operation == AFC_DELETE && param1 == 7)) {
if (debug) fprintf(stderr, "Oops? Bad operation code received: 0x%X, operation=0x%X, param1=%d\n",
if (debug)
fprintf(stderr,
"Oops? Bad operation code received: 0x%X, operation=0x%X, param1=%d\n",
r_packet->operation, client->afc_packet->operation, param1);
recv_len = r_packet->entire_length - r_packet->this_length;
free(r_packet);
if (debug) fprintf(stderr, "recv_len=%d\n", recv_len);
if(param1 == 0) {
if (debug) fprintf(stderr, "... false alarm, but still\n");
if (debug)
fprintf(stderr, "recv_len=%d\n", recv_len);
if (param1 == 0) {
if (debug)
fprintf(stderr, "... false alarm, but still\n");
*dump_here = NULL;
return 0;
} else {
if (debug)
fprintf(stderr, "Errno %i\n", param1);
}
else { if (debug) fprintf(stderr, "Errno %i\n", param1); }
*dump_here = NULL;
return -1;
} else {
if (debug) fprintf(stderr, "Operation code %x\nFull length %i and this length %i\n", r_packet->operation, r_packet->entire_length, r_packet->this_length);
if (debug)
fprintf(stderr,
"Operation code %x\nFull length %i and this length %i\n",
r_packet->operation, r_packet->entire_length, r_packet->this_length);
}
recv_len = r_packet->entire_length - r_packet->this_length;
free(r_packet);
if (!recv_len && r_packet->operation == AFC_SUCCESS_RESPONSE)
{
if (!recv_len && r_packet->operation == AFC_SUCCESS_RESPONSE) {
*dump_here = NULL;
return 0;
}
// Keep collecting packets until we have received the entire file.
buffer = (char*)malloc(sizeof(char) * (recv_len < MAXIMUM_PACKET_SIZE) ? recv_len : MAXIMUM_PACKET_SIZE);
final_buffer = (char*)malloc(sizeof(char) * recv_len);
while(current_count < recv_len){
iphone_mux_recv(client->connection, buffer, recv_len-current_count, &bytes);
if (debug) fprintf(stderr, "receive_AFC_data: still collecting packets\n");
if (bytes < 0)
{
if(debug) fprintf(stderr, "receive_AFC_data: mux_recv failed: %d\n", bytes);
buffer = (char *) malloc(sizeof(char) * (recv_len < MAXIMUM_PACKET_SIZE) ? recv_len : MAXIMUM_PACKET_SIZE);
final_buffer = (char *) malloc(sizeof(char) * recv_len);
while (current_count < recv_len) {
iphone_mux_recv(client->connection, buffer, recv_len - current_count, &bytes);
if (debug)
fprintf(stderr, "receive_AFC_data: still collecting packets\n");
if (bytes < 0) {
if (debug)
fprintf(stderr, "receive_AFC_data: mux_recv failed: %d\n", bytes);
break;
}
if (bytes > recv_len-current_count)
{
if(debug) fprintf(stderr, "receive_AFC_data: mux_recv delivered too much data\n");
if (bytes > recv_len - current_count) {
if (debug)
fprintf(stderr, "receive_AFC_data: mux_recv delivered too much data\n");
break;
}
if (bytes > 7 && strstr(buffer, "CFA6LPAA")) {
if (debug) fprintf(stderr, "receive_AFC_data: WARNING: there is AFC data in this packet at %ti\n", strstr(buffer, "CFA6LPAA") - buffer);
if (debug) fprintf(stderr, "receive_AFC_data: the total packet length is %i\n", bytes);
if (debug)
fprintf(stderr,
"receive_AFC_data: WARNING: there is AFC data in this packet at %ti\n",
strstr(buffer, "CFA6LPAA") - buffer);
if (debug)
fprintf(stderr, "receive_AFC_data: the total packet length is %i\n", bytes);
}
memcpy(final_buffer+current_count, buffer, bytes);
memcpy(final_buffer + current_count, buffer, bytes);
current_count += bytes;
}
free(buffer);
......@@ -291,26 +324,30 @@ static int receive_AFC_data(iphone_afc_client_t client, char **dump_here) {
return current_count;
}
static int count_nullspaces(char *string, int number) {
static int count_nullspaces(char *string, int number)
{
int i = 0, nulls = 0;
for (i = 0; i < number; i++) {
if (string[i] == '\0') nulls++;
if (string[i] == '\0')
nulls++;
}
return nulls;
}
static char **make_strings_list(char *tokens, int true_length) {
static char **make_strings_list(char *tokens, int true_length)
{
int nulls = 0, i = 0, j = 0;
char **list = NULL;
if (!tokens || !true_length) return NULL;
if (!tokens || !true_length)
return NULL;
nulls = count_nullspaces(tokens, true_length);
list = (char**)malloc(sizeof(char*) * (nulls + 1));
list = (char **) malloc(sizeof(char *) * (nulls + 1));
for (i = 0; i < nulls; i++) {
list[i] = strdup(tokens+j);
list[i] = strdup(tokens + j);
j += strlen(list[i]) + 1;
}
list[i] = NULL;
......@@ -326,12 +363,14 @@ static char **make_strings_list(char *tokens, int true_length) {
* @return A char ** list of files in that directory, terminated by an empty
* string for now or NULL if there was an error.
*/
iphone_error_t iphone_afc_get_dir_list ( iphone_afc_client_t client, const char *dir, char ***list) {
iphone_error_t iphone_afc_get_dir_list(iphone_afc_client_t client, const char *dir, char ***list)
{
int bytes = 0;
char *data = NULL, **list_loc = NULL;
iphone_error_t ret = IPHONE_E_UNKNOWN_ERROR;
if (!client || !dir || !list || (list && *list)) return IPHONE_E_INVALID_ARG;
if (!client || !dir || !list || (list && *list))
return IPHONE_E_INVALID_ARG;
afc_lock(client);
......@@ -344,18 +383,18 @@ iphone_error_t iphone_afc_get_dir_list ( iphone_afc_client_t client, const char
afc_unlock(client);
return IPHONE_E_NOT_ENOUGH_DATA;
}
// Receive the data
bytes = receive_AFC_data(client, &data);
if (bytes < 0 && !data) {
afc_unlock(client);
return IPHONE_E_NOT_ENOUGH_DATA;
}
// Parse the data
list_loc = make_strings_list(data, bytes);
if (list_loc) ret = IPHONE_E_SUCCESS;
if (data) free(data);
if (list_loc)
ret = IPHONE_E_SUCCESS;
if (data)
free(data);
afc_unlock(client);
*list = list_loc;
......@@ -370,11 +409,13 @@ iphone_error_t iphone_afc_get_dir_list ( iphone_afc_client_t client, const char
* @return A char ** list of parameters as given by AFC or NULL if there was an
* error.
*/
iphone_error_t iphone_afc_get_devinfo ( iphone_afc_client_t client, char ***infos) {
iphone_error_t iphone_afc_get_devinfo(iphone_afc_client_t client, char ***infos)
{
int bytes = 0;
char *data = NULL, **list = NULL;
if (!client || !infos) return IPHONE_E_INVALID_ARG;
if (!client || !infos)
return IPHONE_E_INVALID_ARG;
afc_lock(client);
......@@ -386,17 +427,16 @@ iphone_error_t iphone_afc_get_devinfo ( iphone_afc_client_t client, char ***info
afc_unlock(client);
return IPHONE_E_NOT_ENOUGH_DATA;
}
// Receive the data
bytes = receive_AFC_data(client, &data);
if (bytes < 0 && !data) {
afc_unlock(client);
return IPHONE_E_NOT_ENOUGH_DATA;
}
// Parse the data
list = make_strings_list(data, bytes);
if (data) free(data);
if (data)
free(data);
afc_unlock(client);
*infos = list;
......@@ -411,11 +451,13 @@ iphone_error_t iphone_afc_get_devinfo ( iphone_afc_client_t client, char ***info
* @return IPHONE_E_SUCCESS if everythong went well, IPHONE_E_INVALID_ARG
* if arguments are NULL or invalid, IPHONE_E_NOT_ENOUGH_DATA otherwise.
*/
iphone_error_t iphone_afc_delete_file ( iphone_afc_client_t client, const char *path) {
iphone_error_t iphone_afc_delete_file(iphone_afc_client_t client, const char *path)
{
char *response = NULL;
int bytes;
if (!client || !path || !client->afc_packet || !client->connection) return IPHONE_E_INVALID_ARG;
if (!client || !path || !client->afc_packet || !client->connection)
return IPHONE_E_INVALID_ARG;
afc_lock(client);
......@@ -427,10 +469,10 @@ iphone_error_t iphone_afc_delete_file ( iphone_afc_client_t client, const char *
afc_unlock(client);
return IPHONE_E_NOT_ENOUGH_DATA;
}
// Receive response
bytes = receive_AFC_data(client, &response);
if (response) free(response);
if (response)
free(response);
afc_unlock(client);
......@@ -450,18 +492,20 @@ iphone_error_t iphone_afc_delete_file ( iphone_afc_client_t client, const char *
* @return IPHONE_E_SUCCESS if everythong went well, IPHONE_E_INVALID_ARG
* if arguments are NULL or invalid, IPHONE_E_NOT_ENOUGH_DATA otherwise.
*/
iphone_error_t iphone_afc_rename_file ( iphone_afc_client_t client, const char *from, const char *to) {
iphone_error_t iphone_afc_rename_file(iphone_afc_client_t client, const char *from, const char *to)
{
char *response = NULL;
char *send = (char*)malloc(sizeof(char) * (strlen(from) + strlen(to) + 1 + sizeof(uint32)));
char *send = (char *) malloc(sizeof(char) * (strlen(from) + strlen(to) + 1 + sizeof(uint32)));
int bytes = 0;
if (!client || !from || !to || !client->afc_packet || !client->connection) return IPHONE_E_INVALID_ARG;
if (!client || !from || !to || !client->afc_packet || !client->connection)
return IPHONE_E_INVALID_ARG;
afc_lock(client);
// Send command
memcpy(send, from, strlen(from)+1);
memcpy(send+strlen(from)+1, to, strlen(to)+1);
memcpy(send, from, strlen(from) + 1);
memcpy(send + strlen(from) + 1, to, strlen(to) + 1);
client->afc_packet->entire_length = client->afc_packet->this_length = 0;
client->afc_packet->operation = AFC_RENAME;
bytes = dispatch_AFC_packet(client, send, strlen(to) + strlen(from) + 2);
......@@ -470,10 +514,10 @@ iphone_error_t iphone_afc_rename_file ( iphone_afc_client_t client, const char *
afc_unlock(client);
return IPHONE_E_NOT_ENOUGH_DATA;
}
// Receive response
bytes = receive_AFC_data(client, &response);
if (response) free(response);
if (response)
free(response);
afc_unlock(client);
......@@ -493,11 +537,13 @@ iphone_error_t iphone_afc_rename_file ( iphone_afc_client_t client, const char *
* @return IPHONE_E_SUCCESS if everythong went well, IPHONE_E_INVALID_ARG
* if arguments are NULL or invalid, IPHONE_E_NOT_ENOUGH_DATA otherwise.
*/
iphone_error_t iphone_afc_mkdir ( iphone_afc_client_t client, const char *dir) {
iphone_error_t iphone_afc_mkdir(iphone_afc_client_t client, const char *dir)
{
int bytes = 0;
char *response = NULL;
if (!client) return IPHONE_E_INVALID_ARG;
if (!client)
return IPHONE_E_INVALID_ARG;
afc_lock(client);
......@@ -509,10 +555,10 @@ iphone_error_t iphone_afc_mkdir ( iphone_afc_client_t client, const char *dir) {
afc_unlock(client);
return IPHONE_E_NOT_ENOUGH_DATA;
}
// Receive response
bytes = receive_AFC_data(client, &response);
if (response) free(response);
if (response)
free(response);
afc_unlock(client);
......@@ -531,7 +577,8 @@ iphone_error_t iphone_afc_mkdir ( iphone_afc_client_t client, const char *dir) {
* @return A pointer to an AFCFile struct containing the information received,
* or NULL on failure.
*/
iphone_afc_file_t afc_get_file_info(iphone_afc_client_t client, const char *path) {
iphone_afc_file_t afc_get_file_info(iphone_afc_client_t client, const char *path)
{
char *received, **list;
iphone_afc_file_t my_file;
int length, i = 0;
......@@ -557,20 +604,20 @@ iphone_afc_file_t afc_get_file_info(iphone_afc_client_t client, const char *path
// Parse the data
if (list) {
my_file = (iphone_afc_file_t)malloc(sizeof(struct iphone_afc_file_int));
my_file = (iphone_afc_file_t) malloc(sizeof(struct iphone_afc_file_int));
for (i = 0; list[i]; i++) {
if (!strcmp(list[i], "st_size")) {
my_file->size = atoi(list[i+1]);
my_file->size = atoi(list[i + 1]);
}
if (!strcmp(list[i], "st_blocks")) {
my_file->blocks = atoi(list[i+1]);
my_file->blocks = atoi(list[i + 1]);
}
if (!strcmp(list[i], "st_ifmt")) {
if (!strcmp(list[i+1], "S_IFREG")) {
if (!strcmp(list[i + 1], "S_IFREG")) {
my_file->type = S_IFREG;
} else if (!strcmp(list[i+1], "S_IFDIR")) {
} else if (!strcmp(list[i + 1], "S_IFDIR")) {
my_file->type = S_IFDIR;
}
}
......@@ -591,24 +638,27 @@ iphone_afc_file_t afc_get_file_info(iphone_afc_client_t client, const char *path
* @return A pointer to an AFCFile struct containing the information received,
* or NULL on failure.
*/
iphone_error_t iphone_afc_get_file_attr ( iphone_afc_client_t client, const char *filename, struct stat *stbuf ) {
iphone_error_t iphone_afc_get_file_attr(iphone_afc_client_t client, const char *filename, struct stat * stbuf)
{
iphone_error_t ret = IPHONE_E_UNKNOWN_ERROR;
if (!client ||!client->connection || !client->afc_packet || !stbuf) return IPHONE_E_INVALID_ARG;
if (!client || !client->connection || !client->afc_packet || !stbuf)
return IPHONE_E_INVALID_ARG;
memset(stbuf, 0, sizeof(struct stat));
iphone_afc_file_t file = afc_get_file_info(client, filename);
if (!file){
if (!file) {
ret = IPHONE_E_NO_SUCH_FILE;
} else {
stbuf->st_mode = file->type | (S_ISDIR(file->type) ? 0755 : 0644);
stbuf->st_size = file->size;
stbuf->st_blksize = 2048; // FIXME: Is this the actual block size used on the iPhone?
stbuf->st_blksize = 2048; // FIXME: Is this the actual block
// size used on the iPhone?
stbuf->st_blocks = file->blocks;
stbuf->st_uid = getuid();
stbuf->st_gid = getgid();
ret = iphone_afc_close_file(client,file);
ret = iphone_afc_close_file(client, file);
}
return ret;
}
......@@ -626,32 +676,36 @@ iphone_error_t iphone_afc_get_file_attr ( iphone_afc_client_t client, const char
* received by afc_get_file_info) as well as the handle to the file or
* NULL in the case of failure.
*/
iphone_error_t iphone_afc_open_file ( iphone_afc_client_t client, const char *filename, iphone_afc_file_mode_t file_mode, iphone_afc_file_t *file ) {
iphone_error_t
iphone_afc_open_file(iphone_afc_client_t client, const char *filename,
iphone_afc_file_mode_t file_mode, iphone_afc_file_t * file)
{
iphone_afc_file_t file_loc = NULL;
uint32 ag = 0;
int bytes = 0, length = 0;
char *data = (char*)malloc(sizeof(char) * (8 + strlen(filename) + 1));
char *data = (char *) malloc(sizeof(char) * (8 + strlen(filename) + 1));
if (!client ||!client->connection || !client->afc_packet) return IPHONE_E_INVALID_ARG;
if (!client || !client->connection || !client->afc_packet)
return IPHONE_E_INVALID_ARG;
afc_lock(client);
// Send command
memcpy(data, &file_mode, 4);
memcpy(data+4, &ag, 4);
memcpy(data+8, filename, strlen(filename));
data[8+strlen(filename)] = '\0';
memcpy(data + 4, &ag, 4);
memcpy(data + 8, filename, strlen(filename));
data[8 + strlen(filename)] = '\0';
client->afc_packet->operation = AFC_FILE_OPEN;
client->afc_packet->entire_length = client->afc_packet->this_length = 0;
bytes = dispatch_AFC_packet(client, data, 8+strlen(filename));
bytes = dispatch_AFC_packet(client, data, 8 + strlen(filename));
free(data);
if (bytes <= 0) {
if (debug) fprintf(stderr, "afc_open_file: Didn't receive a response to the command\n");
if (debug)
fprintf(stderr, "afc_open_file: Didn't receive a response to the command\n");
afc_unlock(client);
return IPHONE_E_NOT_ENOUGH_DATA;
}
// Receive the data
length = receive_AFC_data(client, &data);
if (length > 0 && data) {
......@@ -664,7 +718,8 @@ iphone_error_t iphone_afc_open_file ( iphone_afc_client_t client, const char *fi
*file = file_loc;
return IPHONE_E_SUCCESS;
} else {
if (debug) fprintf(stderr, "afc_open_file: Didn't get any further data\n");
if (debug)
fprintf(stderr, "afc_open_file: Didn't get any further data\n");
afc_unlock(client);
return IPHONE_E_NOT_ENOUGH_DATA;
}
......@@ -683,58 +738,69 @@ iphone_error_t iphone_afc_open_file ( iphone_afc_client_t client, const char *fi
*
* @return The number of bytes read if successful. If there was an error -1.
*/
iphone_error_t iphone_afc_read_file ( iphone_afc_client_t client, iphone_afc_file_t file, char *data, int length, uint32_t *bytes) {
iphone_error_t
iphone_afc_read_file(iphone_afc_client_t client, iphone_afc_file_t file, char *data, int length, uint32_t * bytes)
{
char *input = NULL;
int current_count = 0, bytes_loc = 0;
const int MAXIMUM_READ_SIZE = 1 << 16;
if (!client || !client->afc_packet || !client->connection || !file) return IPHONE_E_INVALID_ARG;
if (debug) fprintf(stderr, "afc_read_file called for length %i\n", length);
if (!client || !client->afc_packet || !client->connection || !file)
return IPHONE_E_INVALID_ARG;
if (debug)
fprintf(stderr, "afc_read_file called for length %i\n", length);
afc_lock(client);
// Looping here to get around the maximum amount of data that recieve_AFC_data can handle
while (current_count < length){
if (debug) fprintf(stderr, "afc_read_file: current count is %i but length is %i\n", current_count, length);
// Looping here to get around the maximum amount of data that
// recieve_AFC_data can handle
while (current_count < length) {
if (debug)
fprintf(stderr, "afc_read_file: current count is %i but length is %i\n", current_count, length);
// Send the read command
AFCFilePacket *packet = (AFCFilePacket*)malloc(sizeof(AFCFilePacket));
AFCFilePacket *packet = (AFCFilePacket *) malloc(sizeof(AFCFilePacket));
packet->unknown1 = packet->unknown2 = 0;
packet->filehandle = file->filehandle;
packet->size = ((length - current_count) < MAXIMUM_READ_SIZE) ? (length - current_count) : MAXIMUM_READ_SIZE;
client->afc_packet->operation = AFC_READ;
client->afc_packet->entire_length = client->afc_packet->this_length = 0;
bytes_loc = dispatch_AFC_packet(client, (char*)packet, sizeof(AFCFilePacket));
bytes_loc = dispatch_AFC_packet(client, (char *) packet, sizeof(AFCFilePacket));
free(packet);
if (bytes_loc <= 0) {
afc_unlock(client);
return IPHONE_E_NOT_ENOUGH_DATA;
}
// Receive the data
bytes_loc = receive_AFC_data(client, &input);
if (debug) fprintf(stderr, "afc_read_file: bytes returned: %i\n", bytes_loc);
if (debug)
fprintf(stderr, "afc_read_file: bytes returned: %i\n", bytes_loc);
if (bytes_loc < 0) {
if (input) free(input);
if (input)
free(input);
afc_unlock(client);
return IPHONE_E_NOT_ENOUGH_DATA;
} else if (bytes_loc == 0) {
if (input) free(input);
if (input)
free(input);
afc_unlock(client);
*bytes = current_count;
return IPHONE_E_SUCCESS; //FIXME check that's actually a success
return IPHONE_E_SUCCESS; // FIXME check that's actually a
// success
} else {
if (input) {
if (debug) fprintf(stderr, "afc_read_file: %d\n", bytes_loc);
memcpy(data+current_count, input, (bytes_loc > length) ? length : bytes_loc);
if (debug)
fprintf(stderr, "afc_read_file: %d\n", bytes_loc);
memcpy(data + current_count, input, (bytes_loc > length) ? length : bytes_loc);
free(input);
input = NULL;
current_count += (bytes_loc > length) ? length : bytes_loc;
}
}
}
if (debug) fprintf(stderr, "afc_read_file: returning current_count as %i\n", current_count);
if (debug)
fprintf(stderr, "afc_read_file: returning current_count as %i\n", current_count);
afc_unlock(client);
*bytes = current_count;
......@@ -751,17 +817,22 @@ iphone_error_t iphone_afc_read_file ( iphone_afc_client_t client, iphone_afc_fil
* @return The number of bytes written to the file, or a value less than 0 if
* none were written...
*/
iphone_error_t iphone_afc_write_file ( iphone_afc_client_t client, iphone_afc_file_t file, const char *data, int length, uint32_t *bytes) {
iphone_error_t
iphone_afc_write_file(iphone_afc_client_t client, iphone_afc_file_t file,
const char *data, int length, uint32_t * bytes)
{
char *acknowledgement = NULL;
const int MAXIMUM_WRITE_SIZE = 1 << 16;
uint32 zero = 0, bytes_loc = 0, segments = (length / MAXIMUM_WRITE_SIZE), current_count = 0, i = 0;
char *out_buffer = NULL;
if (!client ||!client->afc_packet || !client->connection || !file || !bytes) return IPHONE_E_INVALID_ARG;
if (!client || !client->afc_packet || !client->connection || !file || !bytes)
return IPHONE_E_INVALID_ARG;
afc_lock(client);
if (debug) fprintf(stderr, "afc_write_file: Write length: %i\n", length);
if (debug)
fprintf(stderr, "afc_write_file: Write length: %i\n", length);
// Divide the file into segments.
for (i = 0; i < segments; i++) {
......@@ -769,10 +840,10 @@ iphone_error_t iphone_afc_write_file ( iphone_afc_client_t client, iphone_afc_fi
client->afc_packet->this_length = sizeof(AFCPacket) + 8;
client->afc_packet->entire_length = client->afc_packet->this_length + MAXIMUM_WRITE_SIZE;
client->afc_packet->operation = AFC_WRITE;
out_buffer = (char*)malloc(sizeof(char) * client->afc_packet->entire_length - sizeof(AFCPacket));
memcpy(out_buffer, (char*)&file->filehandle, sizeof(uint32));
memcpy(out_buffer+4, (char*)&zero, sizeof(uint32));
memcpy(out_buffer+8, data+current_count, MAXIMUM_WRITE_SIZE);
out_buffer = (char *) malloc(sizeof(char) * client->afc_packet->entire_length - sizeof(AFCPacket));
memcpy(out_buffer, (char *) &file->filehandle, sizeof(uint32));
memcpy(out_buffer + 4, (char *) &zero, sizeof(uint32));
memcpy(out_buffer + 8, data + current_count, MAXIMUM_WRITE_SIZE);
bytes_loc = dispatch_AFC_packet(client, out_buffer, MAXIMUM_WRITE_SIZE + 8);
if (bytes_loc < 0) {
afc_unlock(client);
......@@ -789,8 +860,10 @@ iphone_error_t iphone_afc_write_file ( iphone_afc_client_t client, iphone_afc_fi
}
}
// By this point, we should be at the end. i.e. the last segment that didn't get sent in the for loop
// this length is fine because it's always sizeof(AFCPacket) + 8, but to be sure we do it again
// By this point, we should be at the end. i.e. the last segment that
// didn't get sent in the for loop
// this length is fine because it's always sizeof(AFCPacket) + 8, but
// to be sure we do it again
if (current_count == length) {
afc_unlock(client);
*bytes = current_count;
......@@ -800,10 +873,10 @@ iphone_error_t iphone_afc_write_file ( iphone_afc_client_t client, iphone_afc_fi
client->afc_packet->this_length = sizeof(AFCPacket) + 8;
client->afc_packet->entire_length = client->afc_packet->this_length + (length - current_count);
client->afc_packet->operation = AFC_WRITE;
out_buffer = (char*)malloc(sizeof(char) * client->afc_packet->entire_length - sizeof(AFCPacket));
memcpy(out_buffer, (char*)&file->filehandle, sizeof(uint32));
memcpy(out_buffer+4, (char*)&zero, sizeof(uint32));
memcpy(out_buffer+8, data+current_count, (length - current_count));
out_buffer = (char *) malloc(sizeof(char) * client->afc_packet->entire_length - sizeof(AFCPacket));
memcpy(out_buffer, (char *) &file->filehandle, sizeof(uint32));
memcpy(out_buffer + 4, (char *) &zero, sizeof(uint32));
memcpy(out_buffer + 8, data + current_count, (length - current_count));
bytes_loc = dispatch_AFC_packet(client, out_buffer, (length - current_count) + 8);
free(out_buffer);
out_buffer = NULL;
......@@ -820,7 +893,8 @@ iphone_error_t iphone_afc_write_file ( iphone_afc_client_t client, iphone_afc_fi
bytes_loc = receive_AFC_data(client, &acknowledgement);
afc_unlock(client);
if (bytes_loc < 0) {
if (debug) fprintf(stderr, "afc_write_file: uh oh?\n");
if (debug)
fprintf(stderr, "afc_write_file: uh oh?\n");
}
*bytes = current_count;
return IPHONE_E_SUCCESS;
......@@ -832,19 +906,22 @@ iphone_error_t iphone_afc_write_file ( iphone_afc_client_t client, iphone_afc_fi
* @param file A pointer to an AFCFile struct containing the file handle of the
* file to close.
*/
iphone_error_t iphone_afc_close_file ( iphone_afc_client_t client, iphone_afc_file_t file) {
if (!client || !file) return IPHONE_E_INVALID_ARG;
iphone_error_t iphone_afc_close_file(iphone_afc_client_t client, iphone_afc_file_t file)
{
if (!client || !file)
return IPHONE_E_INVALID_ARG;
char *buffer = malloc(sizeof(char) * 8);
uint32 zero = 0;
int bytes = 0;
afc_lock(client);
if (debug) fprintf(stderr, "afc_close_file: File handle %i\n", file->filehandle);
if (debug)
fprintf(stderr, "afc_close_file: File handle %i\n", file->filehandle);
// Send command
memcpy(buffer, &file->filehandle, sizeof(uint32));
memcpy(buffer+sizeof(uint32), &zero, sizeof(zero));
memcpy(buffer + sizeof(uint32), &zero, sizeof(zero));
client->afc_packet->operation = AFC_FILE_CLOSE;
client->afc_packet->entire_length = client->afc_packet->this_length = 0;
bytes = dispatch_AFC_packet(client, buffer, sizeof(char) * 8);
......@@ -852,16 +929,17 @@ iphone_error_t iphone_afc_close_file ( iphone_afc_client_t client, iphone_afc_fi
buffer = NULL;
// FIXME: Is this necesary?
//client->afc_packet->entire_length = client->afc_packet->this_length = 0;
// client->afc_packet->entire_length = client->afc_packet->this_length
// = 0;
if (bytes <= 0) {
afc_unlock(client);
return IPHONE_E_UNKNOWN_ERROR;
}
// Receive the response
bytes = receive_AFC_data(client, &buffer);
if (buffer) free(buffer);
if (buffer)
free(buffer);
free(file);
afc_unlock(client);
return IPHONE_E_SUCCESS;
......@@ -876,22 +954,24 @@ iphone_error_t iphone_afc_close_file ( iphone_afc_client_t client, iphone_afc_fi
*
* @return IPHONE_E_SUCCESS on success, IPHONE_E_NOT_ENOUGH_DATA on failure.
*/
iphone_error_t iphone_afc_seek_file ( iphone_afc_client_t client, iphone_afc_file_t file, int seekpos) {
char *buffer = (char*)malloc(sizeof(char) * 24);
iphone_error_t iphone_afc_seek_file(iphone_afc_client_t client, iphone_afc_file_t file, int seekpos)
{
char *buffer = (char *) malloc(sizeof(char) * 24);
uint32 seekto = 0, bytes = 0, zero = 0;
if (seekpos < 0) seekpos = file->size - abs(seekpos);
if (seekpos < 0)
seekpos = file->size - abs(seekpos);
afc_lock(client);
// Send the command
seekto = seekpos;
memcpy(buffer, &file->filehandle, sizeof(uint32)); // handle
memcpy(buffer+4, &zero, sizeof(uint32)); // pad
memcpy(buffer+8, &zero, sizeof(uint32)); // fromwhere
memcpy(buffer+12, &zero, sizeof(uint32)); // pad
memcpy(buffer+16, &seekto, sizeof(uint32)); // offset
memcpy(buffer+20, &zero, sizeof(uint32)); // pad
memcpy(buffer + 4, &zero, sizeof(uint32)); // pad
memcpy(buffer + 8, &zero, sizeof(uint32)); // fromwhere
memcpy(buffer + 12, &zero, sizeof(uint32)); // pad
memcpy(buffer + 16, &seekto, sizeof(uint32)); // offset
memcpy(buffer + 20, &zero, sizeof(uint32)); // pad
client->afc_packet->operation = AFC_FILE_SEEK;
client->afc_packet->this_length = client->afc_packet->entire_length = 0;
bytes = dispatch_AFC_packet(client, buffer, 23);
......@@ -902,10 +982,10 @@ iphone_error_t iphone_afc_seek_file ( iphone_afc_client_t client, iphone_afc_fil
afc_unlock(client);
return IPHONE_E_NOT_ENOUGH_DATA;
}
// Receive response
bytes = receive_AFC_data(client, &buffer);
if (buffer) free(buffer);
if (buffer)
free(buffer);
afc_unlock(client);
......@@ -927,17 +1007,18 @@ iphone_error_t iphone_afc_seek_file ( iphone_afc_client_t client, iphone_afc_fil
* @note This function is more akin to ftruncate than truncate, and truncate
* calls would have to open the file before calling this, sadly.
*/
iphone_error_t iphone_afc_truncate_file ( iphone_afc_client_t client, iphone_afc_file_t file, uint32_t newsize) {
char *buffer = (char*)malloc(sizeof(char) * 16);
iphone_error_t iphone_afc_truncate_file(iphone_afc_client_t client, iphone_afc_file_t file, uint32_t newsize)
{
char *buffer = (char *) malloc(sizeof(char) * 16);
uint32 bytes = 0, zero = 0;
afc_lock(client);
// Send command
memcpy(buffer, &file->filehandle, sizeof(uint32)); // handle
memcpy(buffer+4, &zero, sizeof(uint32)); // pad
memcpy(buffer+8, &newsize, sizeof(uint32)); // newsize
memcpy(buffer+12, &zero, 3); // pad
memcpy(buffer + 4, &zero, sizeof(uint32)); // pad
memcpy(buffer + 8, &newsize, sizeof(uint32)); // newsize
memcpy(buffer + 12, &zero, 3); // pad
client->afc_packet->operation = AFC_FILE_TRUNCATE;
client->afc_packet->this_length = client->afc_packet->entire_length = 0;
bytes = dispatch_AFC_packet(client, buffer, 15);
......@@ -948,10 +1029,10 @@ iphone_error_t iphone_afc_truncate_file ( iphone_afc_client_t client, iphone_afc
afc_unlock(client);
return IPHONE_E_NOT_ENOUGH_DATA;
}
// Receive response
bytes = receive_AFC_data(client, &buffer);
if (buffer) free(buffer);
if (buffer)
free(buffer);
afc_unlock(client);
......
......@@ -71,4 +71,3 @@ enum {
AFC_READ = 0x0000000f,
AFC_WRITE = 0x00000010
};
......@@ -42,7 +42,8 @@ iphone_lckd_client_t control = NULL;
int debug = 0;
static int ifuse_getattr(const char *path, struct stat *stbuf) {
static int ifuse_getattr(const char *path, struct stat *stbuf)
{
int res = 0;
iphone_afc_client_t afc = fuse_get_context()->private_data;
......@@ -54,15 +55,15 @@ static int ifuse_getattr(const char *path, struct stat *stbuf) {
return res;
}
static int ifuse_readdir(const char *path, void *buf, fuse_fill_dir_t filler,
off_t offset, struct fuse_file_info *fi) {
static int ifuse_readdir(const char *path, void *buf, fuse_fill_dir_t filler, off_t offset, struct fuse_file_info *fi)
{
int i;
char **dirs = NULL;
iphone_afc_client_t afc = fuse_get_context()->private_data;
iphone_afc_get_dir_list(afc, path, &dirs);
if(!dirs)
if (!dirs)
return -ENOENT;
for (i = 0; dirs[i]; i++) {
......@@ -74,7 +75,8 @@ static int ifuse_readdir(const char *path, void *buf, fuse_fill_dir_t filler,
return 0;
}
static int ifuse_create(const char *path, mode_t mode, struct fuse_file_info *fi) {
static int ifuse_create(const char *path, mode_t mode, struct fuse_file_info *fi)
{
// exactly the same as open but using a different mode
iphone_afc_file_t file = NULL;
iphone_afc_client_t afc = fuse_get_context()->private_data;
......@@ -86,7 +88,8 @@ static int ifuse_create(const char *path, mode_t mode, struct fuse_file_info *fi
return 0;
}
static int ifuse_open(const char *path, struct fuse_file_info *fi) {
static int ifuse_open(const char *path, struct fuse_file_info *fi)
{
iphone_afc_file_t file = NULL;
iphone_afc_client_t afc = fuse_get_context()->private_data;
uint32_t mode = 0;
......@@ -108,8 +111,8 @@ static int ifuse_open(const char *path, struct fuse_file_info *fi) {
return 0;
}
static int ifuse_read(const char *path, char *buf, size_t size, off_t offset,
struct fuse_file_info *fi) {
static int ifuse_read(const char *path, char *buf, size_t size, off_t offset, struct fuse_file_info *fi)
{
int bytes = 0;
iphone_afc_file_t file;
iphone_afc_client_t afc = fuse_get_context()->private_data;
......@@ -118,7 +121,7 @@ static int ifuse_read(const char *path, char *buf, size_t size, off_t offset,
return 0;
file = g_hash_table_lookup(file_handles, &(fi->fh));
if (!file){
if (!file) {
return -ENOENT;
}
......@@ -127,31 +130,36 @@ static int ifuse_read(const char *path, char *buf, size_t size, off_t offset,
return bytes;
}
static int ifuse_write(const char *path, const char *buf, size_t size, off_t offset, struct fuse_file_info *fi) {
static int ifuse_write(const char *path, const char *buf, size_t size, off_t offset, struct fuse_file_info *fi)
{
int bytes = 0;
iphone_afc_file_t file = NULL;
iphone_afc_client_t afc = fuse_get_context()->private_data;
if (size == 0) return 0;
if (size == 0)
return 0;
file = g_hash_table_lookup(file_handles, &(fi->fh));
if (!file) return -ENOENT;
if (!file)
return -ENOENT;
if (IPHONE_E_SUCCESS == iphone_afc_seek_file(afc, file, offset))
iphone_afc_write_file(afc, file, buf, size, &bytes);
return bytes;
}
static int ifuse_fsync(const char *path, int datasync, struct fuse_file_info *fi) {
static int ifuse_fsync(const char *path, int datasync, struct fuse_file_info *fi)
{
return 0;
}
static int ifuse_release(const char *path, struct fuse_file_info *fi){
static int ifuse_release(const char *path, struct fuse_file_info *fi)
{
iphone_afc_file_t file = NULL;
iphone_afc_client_t afc = fuse_get_context()->private_data;
file = g_hash_table_lookup(file_handles, &(fi->fh));
if (!file){
if (!file) {
return -ENOENT;
}
iphone_afc_close_file(afc, file);
......@@ -161,7 +169,8 @@ static int ifuse_release(const char *path, struct fuse_file_info *fi){
return 0;
}
void *ifuse_init(struct fuse_conn_info *conn) {
void *ifuse_init(struct fuse_conn_info *conn)
{
int port = 0;
iphone_afc_client_t afc = NULL;
......@@ -170,7 +179,7 @@ void *ifuse_init(struct fuse_conn_info *conn) {
file_handles = g_hash_table_new(g_int_hash, g_int_equal);
iphone_get_device(&phone);
if (!phone){
if (!phone) {
fprintf(stderr, "No iPhone found, is it connected?\n");
return NULL;
}
......@@ -194,33 +203,37 @@ void *ifuse_init(struct fuse_conn_info *conn) {
return afc;
}
void ifuse_cleanup(void *data) {
iphone_afc_client_t afc = (iphone_afc_client_t )data;
void ifuse_cleanup(void *data)
{
iphone_afc_client_t afc = (iphone_afc_client_t) data;
iphone_afc_free_client(afc);
iphone_lckd_free_client(control);
iphone_free_device(phone);
}
int ifuse_flush(const char *path, struct fuse_file_info *fi) {
int ifuse_flush(const char *path, struct fuse_file_info *fi)
{
return 0;
}
int ifuse_statfs(const char *path, struct statvfs *stats) {
int ifuse_statfs(const char *path, struct statvfs *stats)
{
iphone_afc_client_t afc = fuse_get_context()->private_data;
char **info_raw = NULL;
uint32_t totalspace = 0, freespace = 0, blocksize = 0, i = 0;
iphone_afc_get_devinfo(afc, &info_raw);
if (!info_raw) return -ENOENT;
if (!info_raw)
return -ENOENT;
for (i = 0; info_raw[i]; i++) {
if (!strcmp(info_raw[i], "FSTotalBytes")) {
totalspace = atoi(info_raw[i+1]);
totalspace = atoi(info_raw[i + 1]);
} else if (!strcmp(info_raw[i], "FSFreeBytes")) {
freespace = atoi(info_raw[i+1]);
freespace = atoi(info_raw[i + 1]);
} else if (!strcmp(info_raw[i], "FSBlockSize")) {
blocksize = atoi(info_raw[i+1]);
blocksize = atoi(info_raw[i + 1]);
}
}
free_dictionary(info_raw);
......@@ -234,42 +247,55 @@ int ifuse_statfs(const char *path, struct statvfs *stats) {
return 0;
}
int ifuse_truncate(const char *path, off_t size) {
int ifuse_truncate(const char *path, off_t size)
{
int result = 0;
iphone_afc_client_t afc = fuse_get_context()->private_data;
iphone_afc_file_t tfile = NULL;
iphone_afc_open_file(afc, path, IPHONE_AFC_FILE_READ, &tfile);
if (!tfile) return -1;
if (!tfile)
return -1;
result = iphone_afc_truncate_file(afc, tfile, size);
iphone_afc_close_file(afc, tfile);
return result;
}
int ifuse_ftruncate(const char *path, off_t size, struct fuse_file_info *fi) {
int ifuse_ftruncate(const char *path, off_t size, struct fuse_file_info *fi)
{
iphone_afc_client_t afc = fuse_get_context()->private_data;
iphone_afc_file_t file = g_hash_table_lookup(file_handles, &fi->fh);
if (!file) return -ENOENT;
if (!file)
return -ENOENT;
return iphone_afc_truncate_file(afc, file, size);
}
int ifuse_unlink(const char *path) {
int ifuse_unlink(const char *path)
{
iphone_afc_client_t afc = fuse_get_context()->private_data;
if (IPHONE_E_SUCCESS == iphone_afc_delete_file(afc, path)) return 0;
else return -1;
if (IPHONE_E_SUCCESS == iphone_afc_delete_file(afc, path))
return 0;
else
return -1;
}
int ifuse_rename(const char *from, const char *to) {
int ifuse_rename(const char *from, const char *to)
{
iphone_afc_client_t afc = fuse_get_context()->private_data;
if (IPHONE_E_SUCCESS == iphone_afc_rename_file(afc, from, to)) return 0;
else return -1;
if (IPHONE_E_SUCCESS == iphone_afc_rename_file(afc, from, to))
return 0;
else
return -1;
}
int ifuse_mkdir(const char *dir, mode_t ignored) {
int ifuse_mkdir(const char *dir, mode_t ignored)
{
iphone_afc_client_t afc = fuse_get_context()->private_data;
if (IPHONE_E_SUCCESS == iphone_afc_mkdir(afc, dir)) return 0;
else return -1;
if (IPHONE_E_SUCCESS == iphone_afc_mkdir(afc, dir))
return 0;
else
return -1;
}
static struct fuse_operations ifuse_oper = {
......@@ -292,6 +318,7 @@ static struct fuse_operations ifuse_oper = {
.destroy = ifuse_cleanup
};
int main(int argc, char *argv[]) {
int main(int argc, char *argv[])
{
return fuse_main(argc, argv, &ifuse_oper, NULL);
}
......@@ -36,38 +36,43 @@ int debug = 1;
*
* @param key The pointer to the desired location of the new key.
*/
void generate_key(gpointer key){
gnutls_x509_privkey_generate(*((gnutls_x509_privkey_t*)key), GNUTLS_PK_RSA, 2048, 0);
void generate_key(gpointer key)
{
gnutls_x509_privkey_generate(*((gnutls_x509_privkey_t *) key), GNUTLS_PK_RSA, 2048, 0);
g_thread_exit(0);
}
/** Simple function that generates a spinner until the mutex is released.
*/
void progress_bar(gpointer mutex){
void progress_bar(gpointer mutex)
{
const char *spinner = "|/-\\|/-\\";
int i = 0;
while (!g_static_mutex_trylock((GStaticMutex*)mutex)){
while (!g_static_mutex_trylock((GStaticMutex *) mutex)) {
usleep(500000);
printf("Generating key... %c\r", spinner[i++]);
fflush(stdout);
if (i > 8) i = 0;
if (i > 8)
i = 0;
}
printf("Generating key... done\n");
g_thread_exit(0);
}
int main(int argc, char *argv[]) {
int main(int argc, char *argv[])
{
GThread *progress_thread, *key_thread;
GError *err;
static GStaticMutex mutex = G_STATIC_MUTEX_INIT;
char* host_id = NULL;
char *host_id = NULL;
gnutls_x509_privkey_t root_privkey;
gnutls_x509_privkey_t host_privkey;
gnutls_x509_crt_t root_cert;
gnutls_x509_crt_t host_cert;
// Create the thread
if (!g_thread_supported()){
if (!g_thread_supported()) {
g_thread_init(NULL);
}
gnutls_global_init();
......@@ -88,13 +93,13 @@ int main(int argc, char *argv[]) {
/* generate root key */
g_static_mutex_lock(&mutex);
if((key_thread = g_thread_create((GThreadFunc)generate_key, &root_privkey, TRUE, &err)) == NULL) {
printf("Thread create failed: %s!!\n", err->message );
g_error_free(err) ;
if ((key_thread = g_thread_create((GThreadFunc) generate_key, &root_privkey, TRUE, &err)) == NULL) {
printf("Thread create failed: %s!!\n", err->message);
g_error_free(err);
}
if((progress_thread = g_thread_create((GThreadFunc)progress_bar, &mutex, TRUE, &err)) == NULL) {
printf("Thread create failed: %s!!\n", err->message );
g_error_free(err) ;
if ((progress_thread = g_thread_create((GThreadFunc) progress_bar, &mutex, TRUE, &err)) == NULL) {
printf("Thread create failed: %s!!\n", err->message);
g_error_free(err);
}
g_thread_join(key_thread);
g_static_mutex_unlock(&mutex);
......@@ -103,13 +108,13 @@ int main(int argc, char *argv[]) {
/* generate host key */
g_static_mutex_init(&mutex);
g_static_mutex_lock(&mutex);
if((key_thread = g_thread_create((GThreadFunc)generate_key, &host_privkey, TRUE, &err)) == NULL) {
printf("Thread create failed: %s!!\n", err->message );
g_error_free(err) ;
if ((key_thread = g_thread_create((GThreadFunc) generate_key, &host_privkey, TRUE, &err)) == NULL) {
printf("Thread create failed: %s!!\n", err->message);
g_error_free(err);
}
if((progress_thread = g_thread_create((GThreadFunc)progress_bar, &mutex, TRUE, &err)) == NULL) {
printf("Thread create failed: %s!!\n", err->message );
g_error_free(err) ;
if ((progress_thread = g_thread_create((GThreadFunc) progress_bar, &mutex, TRUE, &err)) == NULL) {
printf("Thread create failed: %s!!\n", err->message);
g_error_free(err);
}
g_thread_join(key_thread);
g_static_mutex_unlock(&mutex);
......@@ -136,33 +141,33 @@ int main(int argc, char *argv[]) {
/* export to PEM format */
gnutls_datum_t root_key_pem = {NULL, 0};
gnutls_datum_t host_key_pem = {NULL, 0};
gnutls_datum_t root_key_pem = { NULL, 0 };
gnutls_datum_t host_key_pem = { NULL, 0 };
gnutls_x509_privkey_export (root_privkey, GNUTLS_X509_FMT_PEM, NULL, &root_key_pem.size);
gnutls_x509_privkey_export (host_privkey, GNUTLS_X509_FMT_PEM, NULL, &host_key_pem.size);
gnutls_x509_privkey_export(root_privkey, GNUTLS_X509_FMT_PEM, NULL, &root_key_pem.size);
gnutls_x509_privkey_export(host_privkey, GNUTLS_X509_FMT_PEM, NULL, &host_key_pem.size);
root_key_pem.data = gnutls_malloc(root_key_pem.size);
host_key_pem.data = gnutls_malloc(host_key_pem.size);
gnutls_x509_privkey_export (root_privkey, GNUTLS_X509_FMT_PEM, root_key_pem.data, &root_key_pem.size);
gnutls_x509_privkey_export (host_privkey, GNUTLS_X509_FMT_PEM, host_key_pem.data, &host_key_pem.size);
gnutls_x509_privkey_export(root_privkey, GNUTLS_X509_FMT_PEM, root_key_pem.data, &root_key_pem.size);
gnutls_x509_privkey_export(host_privkey, GNUTLS_X509_FMT_PEM, host_key_pem.data, &host_key_pem.size);
gnutls_datum_t root_cert_pem = {NULL, 0};
gnutls_datum_t host_cert_pem = {NULL, 0};
gnutls_datum_t root_cert_pem = { NULL, 0 };
gnutls_datum_t host_cert_pem = { NULL, 0 };
gnutls_x509_crt_export (root_cert, GNUTLS_X509_FMT_PEM, NULL, &root_cert_pem.size);
gnutls_x509_crt_export (host_cert, GNUTLS_X509_FMT_PEM, NULL, &host_cert_pem.size);
gnutls_x509_crt_export(root_cert, GNUTLS_X509_FMT_PEM, NULL, &root_cert_pem.size);
gnutls_x509_crt_export(host_cert, GNUTLS_X509_FMT_PEM, NULL, &host_cert_pem.size);
root_cert_pem.data = gnutls_malloc(root_cert_pem.size);
host_cert_pem.data = gnutls_malloc(host_cert_pem.size);
printf("Generating root certificate...");
gnutls_x509_crt_export (root_cert, GNUTLS_X509_FMT_PEM, root_cert_pem.data, &root_cert_pem.size);
gnutls_x509_crt_export(root_cert, GNUTLS_X509_FMT_PEM, root_cert_pem.data, &root_cert_pem.size);
printf("done\n");
printf("Generating host certificate...");
gnutls_x509_crt_export (host_cert, GNUTLS_X509_FMT_PEM, host_cert_pem.data, &host_cert_pem.size);
gnutls_x509_crt_export(host_cert, GNUTLS_X509_FMT_PEM, host_cert_pem.data, &host_cert_pem.size);
printf("done\n");
......@@ -176,4 +181,3 @@ int main(int argc, char *argv[]) {
return 0;
}
......@@ -34,14 +34,15 @@ extern int debug;
* @return A structure with data on the first iPhone it finds. (Or NULL, on
* error)
*/
iphone_error_t iphone_get_device ( iphone_device_t *device ){
iphone_error_t iphone_get_device(iphone_device_t * device)
{
//check we can actually write in device
if (!device || (device && *device))
return IPHONE_E_INVALID_ARG;
struct usb_bus *bus, *busses;
struct usb_device *dev;
iphone_device_t phone = (iphone_device_t)malloc(sizeof(struct iphone_device_int));
iphone_device_t phone = (iphone_device_t) malloc(sizeof(struct iphone_device_int));
// Initialize the struct
phone->device = NULL;
......@@ -60,9 +61,7 @@ iphone_error_t iphone_get_device ( iphone_device_t *device ){
for (dev = bus->devices; dev; dev = dev->next) {
if (dev->descriptor.idVendor == 0x05ac &&
(dev->descriptor.idProduct == 0x1290 ||
dev->descriptor.idProduct == 0x1291 ||
dev->descriptor.idProduct == 0x1292
)
dev->descriptor.idProduct == 0x1291 || dev->descriptor.idProduct == 0x1292)
) {
phone->__device = dev;
phone->device = usb_open(phone->__device);
......@@ -71,20 +70,21 @@ iphone_error_t iphone_get_device ( iphone_device_t *device ){
break;
}
}
if (phone->__device && phone->device) break;
if (phone->__device && phone->device)
break;
}
// Check to see if we are connected
if (!phone->device || !phone->__device) {
iphone_free_device(phone);
if (debug) fprintf(stderr, "get_iPhone(): iPhone not found\n");
if (debug)
fprintf(stderr, "get_iPhone(): iPhone not found\n");
return IPHONE_E_NO_DEVICE;
}
// Send the version command to the phone
int bytes = 0;
usbmux_version_header *version = version_header();
bytes = usb_bulk_write(phone->device, BULKOUT, (char*)version, sizeof(*version), 800);
bytes = usb_bulk_write(phone->device, BULKOUT, (char *) version, sizeof(*version), 800);
if (bytes < 20 && debug) {
fprintf(stderr, "get_iPhone(): libusb did NOT send enough!\n");
if (bytes < 0) {
......@@ -92,20 +92,20 @@ iphone_error_t iphone_get_device ( iphone_device_t *device ){
bytes, usb_strerror(), strerror(-bytes));
}
}
// Read the phone's response
bytes = usb_bulk_read(phone->device, BULKIN, (char*)version, sizeof(*version), 800);
bytes = usb_bulk_read(phone->device, BULKIN, (char *) version, sizeof(*version), 800);
// Check for bad response
if (bytes < 20) {
free(version);
iphone_free_device(phone);
if (debug) fprintf(stderr, "get_iPhone(): Invalid version message -- header too short.\n");
if (debug && bytes < 0) fprintf(stderr, "get_iPhone(): libusb error message %d: %s (%s)\n",
if (debug)
fprintf(stderr, "get_iPhone(): Invalid version message -- header too short.\n");
if (debug && bytes < 0)
fprintf(stderr, "get_iPhone(): libusb error message %d: %s (%s)\n",
bytes, usb_strerror(), strerror(-bytes));
return IPHONE_E_NOT_ENOUGH_DATA;
}
// Check for correct version
if (ntohl(version->major) == 1 && ntohl(version->minor) == 0) {
// We're all ready to roll.
......@@ -117,12 +117,14 @@ iphone_error_t iphone_get_device ( iphone_device_t *device ){
// Bad header
iphone_free_device(phone);
free(version);
if (debug) fprintf(stderr, "get_iPhone(): Received a bad header/invalid version number.");
if (debug)
fprintf(stderr, "get_iPhone(): Received a bad header/invalid version number.");
return IPHONE_E_BAD_HEADER;
}
// If it got to this point it's gotta be bad
if (debug) fprintf(stderr, "get_iPhone(): Unknown error.\n");
if (debug)
fprintf(stderr, "get_iPhone(): Unknown error.\n");
iphone_free_device(phone);
free(version);
return IPHONE_E_UNKNOWN_ERROR; // if it got to this point it's gotta be bad
......@@ -134,8 +136,10 @@ iphone_error_t iphone_get_device ( iphone_device_t *device ){
*
* @param phone A pointer to an iPhone structure.
*/
iphone_error_t iphone_free_device ( iphone_device_t device ) {
if (!device) return IPHONE_E_INVALID_ARG;
iphone_error_t iphone_free_device(iphone_device_t device)
{
if (!device)
return IPHONE_E_INVALID_ARG;
iphone_error_t ret = IPHONE_E_UNKNOWN_ERROR;
if (device->buffer) {
......@@ -159,17 +163,22 @@ iphone_error_t iphone_free_device ( iphone_device_t device ) {
* @param datalen The length of the data
* @return The number of bytes sent, or -1 on error or something.
*/
int send_to_phone(iphone_device_t phone, char *data, int datalen) {
if (!phone) return -1;
int send_to_phone(iphone_device_t phone, char *data, int datalen)
{
if (!phone)
return -1;
int bytes = 0;
if (!phone) return -1;
if (debug) fprintf(stderr, "send_to_phone: Attempting to send datalen = %i data = %p\n", datalen, data);
if (!phone)
return -1;
if (debug)
fprintf(stderr, "send_to_phone: Attempting to send datalen = %i data = %p\n", datalen, data);
bytes = usb_bulk_write(phone->device, BULKOUT, data, datalen, 800);
if (bytes < datalen) {
if(debug && bytes < 0)
fprintf(stderr, "send_to_iphone(): libusb gave me the error %d: %s - %s\n", bytes, usb_strerror(), strerror(-bytes));
if (debug && bytes < 0)
fprintf(stderr, "send_to_iphone(): libusb gave me the error %d: %s - %s\n", bytes, usb_strerror(),
strerror(-bytes));
return -1;
} else {
return bytes;
......@@ -186,16 +195,22 @@ int send_to_phone(iphone_device_t phone, char *data, int datalen) {
*
* @return How many bytes were read in, or -1 on error.
*/
int recv_from_phone(iphone_device_t phone, char *data, int datalen) {
if (!phone) return -1;
int recv_from_phone(iphone_device_t phone, char *data, int datalen)
{
if (!phone)
return -1;
int bytes = 0;
if (!phone) return -1;
if (debug) fprintf(stderr, "recv_from_phone(): attempting to receive %i bytes\n", datalen);
if (!phone)
return -1;
if (debug)
fprintf(stderr, "recv_from_phone(): attempting to receive %i bytes\n", datalen);
bytes = usb_bulk_read(phone->device, BULKIN, data, datalen, 3500);
if (bytes < 0) {
if(debug) fprintf(stderr, "recv_from_phone(): libusb gave me the error %d: %s (%s)\n", bytes, usb_strerror(), strerror(-bytes));
if (debug)
fprintf(stderr, "recv_from_phone(): libusb gave me the error %d: %s (%s)\n", bytes, usb_strerror(),
strerror(-bytes));
return -1;
}
......
......@@ -32,16 +32,17 @@
extern int debug;
const ASN1_ARRAY_TYPE pkcs1_asn1_tab[]={
{"PKCS1",536872976,0},
{0,1073741836,0},
{"RSAPublicKey",536870917,0},
{"modulus",1073741827,0},
{"publicExponent",3,0},
{0,0,0}
const ASN1_ARRAY_TYPE pkcs1_asn1_tab[] = {
{"PKCS1", 536872976, 0},
{0, 1073741836, 0},
{"RSAPublicKey", 536870917, 0},
{"modulus", 1073741827, 0},
{"publicExponent", 3, 0},
{0, 0, 0}
};
int get_rand(int min, int max) {
int get_rand(int min, int max)
{
int retval = (rand() % (max - min)) + min;
return retval;
}
......@@ -50,8 +51,9 @@ int get_rand(int min, int max) {
*
* @param A null terminated string containing a valid HostID.
*/
char *lockdownd_generate_hostid() {
char *hostid = (char*)malloc(sizeof(char) * 37); // HostID's are just UUID's, and UUID's are 36 characters long
char *lockdownd_generate_hostid()
{
char *hostid = (char *) malloc(sizeof(char) * 37); // HostID's are just UUID's, and UUID's are 36 characters long
const char *chars = "ABCDEF0123456789";
srand(time(NULL));
int i = 0;
......@@ -61,7 +63,7 @@ char *lockdownd_generate_hostid() {
hostid[i] = '-';
continue;
} else {
hostid[i] = chars[get_rand(0,16)];
hostid[i] = chars[get_rand(0, 16)];
}
}
hostid[36] = '\0'; // make it a real string
......@@ -74,16 +76,18 @@ char *lockdownd_generate_hostid() {
*
* @return The lockdownd client.
*/
iphone_lckd_client_t new_lockdownd_client(iphone_device_t phone) {
if (!phone) return NULL;
iphone_lckd_client_t control = (iphone_lckd_client_t)malloc(sizeof(struct iphone_lckd_client_int));
iphone_lckd_client_t new_lockdownd_client(iphone_device_t phone)
{
if (!phone)
return NULL;
iphone_lckd_client_t control = (iphone_lckd_client_t) malloc(sizeof(struct iphone_lckd_client_int));
if (IPHONE_E_SUCCESS != iphone_mux_new_client ( phone, 0x0a00, 0xf27e, &control->connection)) {
if (IPHONE_E_SUCCESS != iphone_mux_new_client(phone, 0x0a00, 0xf27e, &control->connection)) {
free(control);
return NULL;
}
control->ssl_session = (gnutls_session_t*)malloc(sizeof(gnutls_session_t));
control->ssl_session = (gnutls_session_t *) malloc(sizeof(gnutls_session_t));
control->in_SSL = 0;
control->gtls_buffer_hack_len = 0;
return control;
......@@ -94,15 +98,18 @@ iphone_lckd_client_t new_lockdownd_client(iphone_device_t phone) {
*
* @param control The lockdown client
*/
iphone_error_t iphone_lckd_free_client( iphone_lckd_client_t client ) {
if (!client) return IPHONE_E_INVALID_ARG;
iphone_error_t iphone_lckd_free_client(iphone_lckd_client_t client)
{
if (!client)
return IPHONE_E_INVALID_ARG;
iphone_error_t ret = IPHONE_E_UNKNOWN_ERROR;
if (client->connection) {
ret = iphone_mux_free_client(client->connection);
}
if (client->ssl_session) gnutls_deinit(*client->ssl_session);
if (client->ssl_session)
gnutls_deinit(*client->ssl_session);
free(client->ssl_session);
free(client);
return ret;
......@@ -116,24 +123,30 @@ iphone_error_t iphone_lckd_free_client( iphone_lckd_client_t client ) {
*
* @return The number of bytes received
*/
iphone_error_t iphone_lckd_recv ( iphone_lckd_client_t client, char **dump_data, uint32_t *recv_bytes ) {
if (!client || !dump_data || !recv_bytes) return IPHONE_E_INVALID_ARG;
iphone_error_t iphone_lckd_recv(iphone_lckd_client_t client, char **dump_data, uint32_t * recv_bytes)
{
if (!client || !dump_data || !recv_bytes)
return IPHONE_E_INVALID_ARG;
iphone_error_t ret = IPHONE_E_UNKNOWN_ERROR;
char *receive;
uint32 datalen = 0, bytes = 0;
if (!client->in_SSL) ret = iphone_mux_recv(client->connection, (char *)&datalen, sizeof(datalen), &bytes);
if (!client->in_SSL)
ret = iphone_mux_recv(client->connection, (char *) &datalen, sizeof(datalen), &bytes);
else {
bytes = gnutls_record_recv(*client->ssl_session, &datalen, sizeof(datalen));
if (bytes > 0) ret = IPHONE_E_SUCCESS;
if (bytes > 0)
ret = IPHONE_E_SUCCESS;
}
datalen = ntohl(datalen);
receive = (char*)malloc(sizeof(char) * datalen);
if (!client->in_SSL) ret = iphone_mux_recv(client->connection, receive, datalen, &bytes);
receive = (char *) malloc(sizeof(char) * datalen);
if (!client->in_SSL)
ret = iphone_mux_recv(client->connection, receive, datalen, &bytes);
else {
bytes = gnutls_record_recv(*client->ssl_session, receive, datalen);
if (bytes > 0) ret = IPHONE_E_SUCCESS;
if (bytes > 0)
ret = IPHONE_E_SUCCESS;
}
*dump_data = receive;
*recv_bytes = bytes;
......@@ -151,30 +164,34 @@ iphone_error_t iphone_lckd_recv ( iphone_lckd_client_t client, char **dump_data,
*
* @return The number of bytes sent
*/
iphone_error_t iphone_lckd_send ( iphone_lckd_client_t client, char *raw_data, uint32_t length, uint32_t *sent_bytes ) {
if (!client || !raw_data || length == 0 || !sent_bytes) return IPHONE_E_INVALID_ARG;
iphone_error_t iphone_lckd_send(iphone_lckd_client_t client, char *raw_data, uint32_t length, uint32_t * sent_bytes)
{
if (!client || !raw_data || length == 0 || !sent_bytes)
return IPHONE_E_INVALID_ARG;
char *real_query;
int bytes;
iphone_error_t ret = IPHONE_E_UNKNOWN_ERROR;
real_query = (char*)malloc(sizeof(char) * (length+4));
real_query = (char *) malloc(sizeof(char) * (length + 4));
length = htonl(length);
memcpy(real_query, &length, sizeof(length));
memcpy(real_query+4, raw_data, ntohl(length));
memcpy(real_query + 4, raw_data, ntohl(length));
if (debug) {
printf("lockdownd_send(): made the query, sending it along\n");
FILE *packet = fopen("grpkt", "w");
fwrite(real_query, 1, ntohl(length)+4, packet);
fwrite(real_query, 1, ntohl(length) + 4, packet);
fclose(packet);
packet = NULL;
}
if (!client->in_SSL) ret = iphone_mux_send(client->connection, real_query, ntohl(length)+sizeof(length), &bytes);
if (!client->in_SSL)
ret = iphone_mux_send(client->connection, real_query, ntohl(length) + sizeof(length), &bytes);
else {
gnutls_record_send(*client->ssl_session, real_query, ntohl(length)+sizeof(length));
gnutls_record_send(*client->ssl_session, real_query, ntohl(length) + sizeof(length));
ret = IPHONE_E_SUCCESS;
}
if (debug) printf("lockdownd_send(): sent it!\n");
if (debug)
printf("lockdownd_send(): sent it!\n");
free(real_query);
*sent_bytes = bytes;
return ret;
......@@ -188,41 +205,49 @@ iphone_error_t iphone_lckd_send ( iphone_lckd_client_t client, char *raw_data, u
*
* @return 1 on success and 0 on failure.
*/
iphone_error_t lockdownd_hello(iphone_lckd_client_t control) {
if (!control) return IPHONE_E_INVALID_ARG;
iphone_error_t lockdownd_hello(iphone_lckd_client_t control)
{
if (!control)
return IPHONE_E_INVALID_ARG;
xmlDocPtr plist = new_plist();
xmlNode *dict, *key;
char **dictionary;
int bytes = 0, i = 0;
iphone_error_t ret = IPHONE_E_UNKNOWN_ERROR;
if (debug) printf("lockdownd_hello() called\n");
if (debug)
printf("lockdownd_hello() called\n");
dict = add_child_to_plist(plist, "dict", "\n", NULL, 0);
key = add_key_str_dict_element(plist, dict, "Request", "QueryType", 1);
char *XML_content;
uint32 length;
xmlDocDumpMemory(plist, (xmlChar **)&XML_content, &length);
xmlDocDumpMemory(plist, (xmlChar **) & XML_content, &length);
ret = iphone_lckd_send(control, XML_content, length, &bytes);
xmlFree(XML_content);
xmlFreeDoc(plist); plist = NULL;
xmlFreeDoc(plist);
plist = NULL;
ret = iphone_lckd_recv(control, &XML_content, &bytes);
plist = xmlReadMemory(XML_content, bytes, NULL, NULL, 0);
if (!plist) return IPHONE_E_PLIST_ERROR;
if (!plist)
return IPHONE_E_PLIST_ERROR;
dict = xmlDocGetRootElement(plist);
for (dict = dict->children; dict; dict = dict->next) {
if (!xmlStrcmp(dict->name, "dict")) break;
if (!xmlStrcmp(dict->name, "dict"))
break;
}
if (!dict) return IPHONE_E_DICT_ERROR;
if (!dict)
return IPHONE_E_DICT_ERROR;
dictionary = read_dict_element_strings(dict);
xmlFreeDoc(plist);
free(XML_content);
for (i = 0; dictionary[i]; i+=2) {
if (!strcmp(dictionary[i], "Result") && !strcmp(dictionary[i+1], "Success")) {
if (debug) printf("lockdownd_hello(): success\n");
for (i = 0; dictionary[i]; i += 2) {
if (!strcmp(dictionary[i], "Result") && !strcmp(dictionary[i + 1], "Success")) {
if (debug)
printf("lockdownd_hello(): success\n");
ret = IPHONE_E_SUCCESS;
break;
}
......@@ -242,7 +267,8 @@ iphone_error_t lockdownd_hello(iphone_lckd_client_t control) {
*/
iphone_error_t lockdownd_generic_get_value(iphone_lckd_client_t control, char *req_key, char **value)
{
if (!control || !req_key || !value || (value && *value)) return IPHONE_E_INVALID_ARG;
if (!control || !req_key || !value || (value && *value))
return IPHONE_E_INVALID_ARG;
xmlDocPtr plist = new_plist();
xmlNode *dict = NULL;
xmlNode *key = NULL;;
......@@ -256,28 +282,34 @@ iphone_error_t lockdownd_generic_get_value(iphone_lckd_client_t control, char *r
dict = add_child_to_plist(plist, "dict", "\n", NULL, 0);
key = add_key_str_dict_element(plist, dict, "Key", req_key, 1);
key = add_key_str_dict_element(plist, dict, "Request", "GetValue", 1);
xmlDocDumpMemory(plist, (xmlChar**)&XML_content, &length);
xmlDocDumpMemory(plist, (xmlChar **) & XML_content, &length);
/* send to iPhone */
ret = iphone_lckd_send(control, XML_content, length, &bytes);
xmlFree(XML_content);
xmlFreeDoc(plist); plist = NULL;
xmlFreeDoc(plist);
plist = NULL;
if (ret != IPHONE_E_SUCCESS) return ret;
if (ret != IPHONE_E_SUCCESS)
return ret;
/* Now get iPhone's answer */
ret = iphone_lckd_recv(control, &XML_content, &bytes);
if (ret != IPHONE_E_SUCCESS) return ret;
if (ret != IPHONE_E_SUCCESS)
return ret;
plist = xmlReadMemory(XML_content, bytes, NULL, NULL, 0);
if (!plist) return IPHONE_E_PLIST_ERROR;
if (!plist)
return IPHONE_E_PLIST_ERROR;
dict = xmlDocGetRootElement(plist);
for (dict = dict->children; dict; dict = dict->next) {
if (!xmlStrcmp(dict->name, "dict")) break;
if (!xmlStrcmp(dict->name, "dict"))
break;
}
if (!dict) return IPHONE_E_DICT_ERROR;
if (!dict)
return IPHONE_E_DICT_ERROR;
/* Parse xml to check success and to find public key */
dictionary = read_dict_element_strings(dict);
......@@ -285,12 +317,12 @@ iphone_error_t lockdownd_generic_get_value(iphone_lckd_client_t control, char *r
free(XML_content);
int success = 0;
for (i = 0; dictionary[i]; i+=2) {
if (!strcmp(dictionary[i], "Result") && !strcmp(dictionary[i+1], "Success")) {
for (i = 0; dictionary[i]; i += 2) {
if (!strcmp(dictionary[i], "Result") && !strcmp(dictionary[i + 1], "Success")) {
success = 1;
}
if (!strcmp(dictionary[i], "Value")) {
*value = strdup(dictionary[i+1]);
*value = strdup(dictionary[i + 1]);
}
}
......@@ -298,7 +330,8 @@ iphone_error_t lockdownd_generic_get_value(iphone_lckd_client_t control, char *r
free_dictionary(dictionary);
dictionary = NULL;
}
if (success) ret = IPHONE_E_SUCCESS;
if (success)
ret = IPHONE_E_SUCCESS;
return ret;
}
......@@ -331,15 +364,15 @@ iphone_error_t lockdownd_get_device_public_key(iphone_lckd_client_t control, cha
*
* @return 1 on success and 0 on failure
*/
iphone_error_t iphone_lckd_new_client ( iphone_device_t device, iphone_lckd_client_t *client )
iphone_error_t iphone_lckd_new_client(iphone_device_t device, iphone_lckd_client_t * client)
{
if (!device || !client || (client && *client) )
if (!device || !client || (client && *client))
return IPHONE_E_INVALID_ARG;
iphone_error_t ret = IPHONE_E_SUCCESS;
char *host_id = NULL;
iphone_lckd_client_t client_loc = new_lockdownd_client( device );
if (IPHONE_E_SUCCESS != lockdownd_hello(client_loc)){
iphone_lckd_client_t client_loc = new_lockdownd_client(device);
if (IPHONE_E_SUCCESS != lockdownd_hello(client_loc)) {
fprintf(stderr, "Hello failed in the lockdownd client.\n");
ret = IPHONE_E_NOT_ENOUGH_DATA;
}
......@@ -347,12 +380,12 @@ iphone_error_t iphone_lckd_new_client ( iphone_device_t device, iphone_lckd_clie
char *uid = NULL;
ret = lockdownd_get_device_uid(client_loc, &uid);
if(IPHONE_E_SUCCESS != ret){
if (IPHONE_E_SUCCESS != ret) {
fprintf(stderr, "Device refused to send uid.\n");
}
host_id = get_host_id();
if (IPHONE_E_SUCCESS == ret && !host_id){
if (IPHONE_E_SUCCESS == ret && !host_id) {
fprintf(stderr, "No HostID found, run libiphone-initconf.\n");
ret = IPHONE_E_INVALID_CONF;
}
......@@ -366,7 +399,7 @@ iphone_error_t iphone_lckd_new_client ( iphone_device_t device, iphone_lckd_clie
}
ret = lockdownd_start_SSL_session(client_loc, host_id);
if (IPHONE_E_SUCCESS != ret ) {
if (IPHONE_E_SUCCESS != ret) {
ret = IPHONE_E_SSL_ERROR;
fprintf(stderr, "SSL Session opening failed.\n");
}
......@@ -399,19 +432,19 @@ iphone_error_t lockdownd_pair_device(iphone_lckd_client_t control, char *uid, ch
char *XML_content = NULL;
uint32 length = 0;
char* device_cert_b64 = NULL;
char* host_cert_b64 = NULL;
char* root_cert_b64 = NULL;
char *device_cert_b64 = NULL;
char *host_cert_b64 = NULL;
char *root_cert_b64 = NULL;
char *public_key_b64 = NULL;
ret = lockdownd_get_device_public_key(control, &public_key_b64);
if(ret != IPHONE_E_SUCCESS){
if (ret != IPHONE_E_SUCCESS) {
fprintf(stderr, "Device refused to send public key.\n");
return ret;
}
ret = lockdownd_gen_pair_cert(public_key_b64, &device_cert_b64, &host_cert_b64, &root_cert_b64);
if(ret != IPHONE_E_SUCCESS){
if (ret != IPHONE_E_SUCCESS) {
free(public_key_b64);
return ret;
}
......@@ -426,22 +459,25 @@ iphone_error_t lockdownd_pair_device(iphone_lckd_client_t control, char *uid, ch
add_key_data_dict_element(plist, dictRecord, "RootCertificate", root_cert_b64, 2);
add_key_str_dict_element(plist, dict, "Request", "Pair", 1);
xmlDocDumpMemory(plist, (xmlChar**)&XML_content, &length);
xmlDocDumpMemory(plist, (xmlChar **) & XML_content, &length);
printf("XML Pairing request : %s\n",XML_content);
printf("XML Pairing request : %s\n", XML_content);
/* send to iPhone */
ret = iphone_lckd_send(control, XML_content, length, &bytes);
xmlFree(XML_content);
xmlFreeDoc(plist); plist = NULL;
xmlFreeDoc(plist);
plist = NULL;
if (ret != IPHONE_E_SUCCESS) return ret;
if (ret != IPHONE_E_SUCCESS)
return ret;
/* Now get iPhone's answer */
ret = iphone_lckd_recv(control, &XML_content, &bytes);
if (ret != IPHONE_E_SUCCESS) return ret;
if (ret != IPHONE_E_SUCCESS)
return ret;
if (debug) {
printf("lockdown_pair_device: iPhone's response to our pair request:\n");
......@@ -456,7 +492,8 @@ iphone_error_t lockdownd_pair_device(iphone_lckd_client_t control, char *uid, ch
}
dict = xmlDocGetRootElement(plist);
for (dict = dict->children; dict; dict = dict->next) {
if (!xmlStrcmp(dict->name, "dict")) break;
if (!xmlStrcmp(dict->name, "dict"))
break;
}
if (!dict) {
free(public_key_b64);
......@@ -469,8 +506,8 @@ iphone_error_t lockdownd_pair_device(iphone_lckd_client_t control, char *uid, ch
free(XML_content);
int success = 0;
for (i = 0; dictionary[i]; i+=2) {
if (!strcmp(dictionary[i], "Result") && !strcmp(dictionary[i+1], "Success")) {
for (i = 0; dictionary[i]; i += 2) {
if (!strcmp(dictionary[i], "Result") && !strcmp(dictionary[i + 1], "Success")) {
success = 1;
}
}
......@@ -482,11 +519,13 @@ iphone_error_t lockdownd_pair_device(iphone_lckd_client_t control, char *uid, ch
/* store public key in config if pairing succeeded */
if (success) {
if (debug) printf("lockdownd_pair_device: pair success\n");
if (debug)
printf("lockdownd_pair_device: pair success\n");
store_device_public_key(uid, public_key_b64);
ret = IPHONE_E_SUCCESS;
} else {
if (debug) printf("lockdownd_pair_device: pair failure\n");
if (debug)
printf("lockdownd_pair_device: pair failure\n");
ret = IPHONE_E_PAIRING_FAILED;
}
free(public_key_b64);
......@@ -498,23 +537,25 @@ iphone_error_t lockdownd_pair_device(iphone_lckd_client_t control, char *uid, ch
*
* @return IPHONE_E_SUCCESS on success.
*/
iphone_error_t lockdownd_gen_pair_cert(char *public_key_b64, char **device_cert_b64, char **host_cert_b64, char **root_cert_b64)
iphone_error_t lockdownd_gen_pair_cert(char *public_key_b64, char **device_cert_b64, char **host_cert_b64,
char **root_cert_b64)
{
if (!public_key_b64 || !device_cert_b64 || !host_cert_b64 || !root_cert_b64) return IPHONE_E_INVALID_ARG;
if (!public_key_b64 || !device_cert_b64 || !host_cert_b64 || !root_cert_b64)
return IPHONE_E_INVALID_ARG;
iphone_error_t ret = IPHONE_E_UNKNOWN_ERROR;
gnutls_datum_t modulus = {NULL, 0};
gnutls_datum_t exponent = {NULL, 0};
gnutls_datum_t modulus = { NULL, 0 };
gnutls_datum_t exponent = { NULL, 0 };
/* first decode base64 public_key */
gnutls_datum_t pem_pub_key;
gsize decoded_size;
pem_pub_key.data = g_base64_decode (public_key_b64, &decoded_size);
pem_pub_key.data = g_base64_decode(public_key_b64, &decoded_size);
pem_pub_key.size = decoded_size;
/* now decode the PEM encoded key */
gnutls_datum_t der_pub_key;
if( GNUTLS_E_SUCCESS == gnutls_pem_base64_decode_alloc ("RSA PUBLIC KEY", &pem_pub_key, &der_pub_key) ){
if (GNUTLS_E_SUCCESS == gnutls_pem_base64_decode_alloc("RSA PUBLIC KEY", &pem_pub_key, &der_pub_key)) {
/* initalize asn.1 parser */
ASN1_TYPE pkcs1 = ASN1_TYPE_EMPTY;
......@@ -526,14 +567,14 @@ iphone_error_t lockdownd_gen_pair_cert(char *public_key_b64, char **device_cert_
if (ASN1_SUCCESS == asn1_der_decoding(&asn1_pub_key, der_pub_key.data, der_pub_key.size, NULL)) {
/* get size to read */
int ret1 = asn1_read_value (asn1_pub_key, "modulus", NULL, &modulus.size);
int ret2 = asn1_read_value (asn1_pub_key, "publicExponent", NULL, &exponent.size);
int ret1 = asn1_read_value(asn1_pub_key, "modulus", NULL, &modulus.size);
int ret2 = asn1_read_value(asn1_pub_key, "publicExponent", NULL, &exponent.size);
modulus.data = gnutls_malloc(modulus.size);
exponent.data = gnutls_malloc(exponent.size);
ret1 = asn1_read_value (asn1_pub_key, "modulus", modulus.data, &modulus.size);
ret2 = asn1_read_value (asn1_pub_key, "publicExponent", exponent.data, &exponent.size);
ret1 = asn1_read_value(asn1_pub_key, "modulus", modulus.data, &modulus.size);
ret2 = asn1_read_value(asn1_pub_key, "publicExponent", exponent.data, &exponent.size);
if (ASN1_SUCCESS == ret1 && ASN1_SUCCESS == ret2)
ret = IPHONE_E_SUCCESS;
}
......@@ -548,7 +589,7 @@ iphone_error_t lockdownd_gen_pair_cert(char *public_key_b64, char **device_cert_
if (IPHONE_E_SUCCESS == ret && 0 != modulus.size && 0 != exponent.size) {
gnutls_global_init();
gnutls_datum_t essentially_null = {strdup("abababababababab"), strlen("abababababababab")};
gnutls_datum_t essentially_null = { strdup("abababababababab"), strlen("abababababababab") };
gnutls_x509_privkey_t fake_privkey, root_privkey;
gnutls_x509_crt_t dev_cert, root_cert, host_cert;
......@@ -558,24 +599,26 @@ iphone_error_t lockdownd_gen_pair_cert(char *public_key_b64, char **device_cert_
gnutls_x509_crt_init(&root_cert);
gnutls_x509_crt_init(&host_cert);
if ( GNUTLS_E_SUCCESS == gnutls_x509_privkey_import_rsa_raw(fake_privkey, &modulus, &exponent, &essentially_null, &essentially_null, &essentially_null, &essentially_null) ) {
if (GNUTLS_E_SUCCESS ==
gnutls_x509_privkey_import_rsa_raw(fake_privkey, &modulus, &exponent, &essentially_null, &essentially_null,
&essentially_null, &essentially_null)) {
gnutls_x509_privkey_init(&root_privkey);
/* get root cert */
gnutls_datum_t pem_root_cert = {NULL, 0};
gnutls_datum_t pem_root_cert = { NULL, 0 };
get_root_certificate(&pem_root_cert);
if (GNUTLS_E_SUCCESS != gnutls_x509_crt_import(root_cert, &pem_root_cert, GNUTLS_X509_FMT_PEM))
ret = IPHONE_E_SSL_ERROR;
/* get host cert */
gnutls_datum_t pem_host_cert = {NULL, 0};
gnutls_datum_t pem_host_cert = { NULL, 0 };
get_host_certificate(&pem_host_cert);
if (GNUTLS_E_SUCCESS != gnutls_x509_crt_import(host_cert, &pem_host_cert, GNUTLS_X509_FMT_PEM))
ret = IPHONE_E_SSL_ERROR;
/* get root private key */
gnutls_datum_t pem_root_priv = {NULL, 0};
gnutls_datum_t pem_root_priv = { NULL, 0 };
get_root_private_key(&pem_root_priv);
if (GNUTLS_E_SUCCESS != gnutls_x509_privkey_import(root_privkey, &pem_root_priv, GNUTLS_X509_FMT_PEM))
ret = IPHONE_E_SSL_ERROR;
......@@ -591,7 +634,7 @@ iphone_error_t lockdownd_gen_pair_cert(char *public_key_b64, char **device_cert_
if (IPHONE_E_SUCCESS == ret) {
/* if everything went well, export in PEM format */
gnutls_datum_t dev_pem = {NULL, 0};
gnutls_datum_t dev_pem = { NULL, 0 };
gnutls_x509_crt_export(dev_cert, GNUTLS_X509_FMT_PEM, NULL, &dev_pem.size);
dev_pem.data = gnutls_malloc(dev_pem.size);
gnutls_x509_crt_export(dev_cert, GNUTLS_X509_FMT_PEM, dev_pem.data, &dev_pem.size);
......@@ -623,7 +666,8 @@ iphone_error_t lockdownd_gen_pair_cert(char *public_key_b64, char **device_cert_
*
* @return 1 on success and 0 on failure
*/
iphone_error_t lockdownd_start_SSL_session(iphone_lckd_client_t control, const char *HostID) {
iphone_error_t lockdownd_start_SSL_session(iphone_lckd_client_t control, const char *HostID)
{
xmlDocPtr plist = new_plist();
xmlNode *dict = add_child_to_plist(plist, "dict", "\n", NULL, 0);
xmlNode *key;
......@@ -634,43 +678,49 @@ iphone_error_t lockdownd_start_SSL_session(iphone_lckd_client_t control, const c
key = add_key_str_dict_element(plist, dict, "HostID", HostID, 1);
if (!key) {
if (debug) printf("Couldn't add a key.\n");
if (debug)
printf("Couldn't add a key.\n");
xmlFreeDoc(plist);
return IPHONE_E_DICT_ERROR;
}
key = add_key_str_dict_element(plist, dict, "Request", "StartSession", 1);
if (!key) {
if (debug) printf("Couldn't add a key.\n");
if (debug)
printf("Couldn't add a key.\n");
xmlFreeDoc(plist);
return IPHONE_E_DICT_ERROR;
}
xmlDocDumpMemory(plist, (xmlChar **)&what2send, &len);
xmlDocDumpMemory(plist, (xmlChar **) & what2send, &len);
ret = iphone_lckd_send(control, what2send, len, &bytes);
xmlFree(what2send);
xmlFreeDoc(plist);
if (ret != IPHONE_E_SUCCESS) return ret;
if (ret != IPHONE_E_SUCCESS)
return ret;
if (bytes > 0) {
ret = iphone_lckd_recv(control, &what2send, &len);
plist = xmlReadMemory(what2send, len, NULL, NULL, 0);
dict = xmlDocGetRootElement(plist);
if (!dict) return IPHONE_E_DICT_ERROR;
if (!dict)
return IPHONE_E_DICT_ERROR;
for (dict = dict->children; dict; dict = dict->next) {
if (!xmlStrcmp(dict->name, "dict")) break;
if (!xmlStrcmp(dict->name, "dict"))
break;
}
dictionary = read_dict_element_strings(dict);
xmlFreeDoc(plist);
free(what2send);
for (i = 0; dictionary[i]; i+=2) {
if (!strcmp(dictionary[i], "Result") && !strcmp(dictionary[i+1], "Success")) {
for (i = 0; dictionary[i]; i += 2) {
if (!strcmp(dictionary[i], "Result") && !strcmp(dictionary[i + 1], "Success")) {
// Set up GnuTLS...
//gnutls_anon_client_credentials_t anoncred;
gnutls_certificate_credentials_t xcred;
if (debug) printf("We started the session OK, now trying GnuTLS\n");
if (debug)
printf("We started the session OK, now trying GnuTLS\n");
errno = 0;
gnutls_global_init();
//gnutls_anon_allocate_client_credentials(&anoncred);
......@@ -678,7 +728,7 @@ iphone_error_t lockdownd_start_SSL_session(iphone_lckd_client_t control, const c
gnutls_certificate_set_x509_trust_file(xcred, "hostcert.pem", GNUTLS_X509_FMT_PEM);
gnutls_init(control->ssl_session, GNUTLS_CLIENT);
{
int protocol_priority[16] = {GNUTLS_SSL3, 0 };
int protocol_priority[16] = { GNUTLS_SSL3, 0 };
int kx_priority[16] = { GNUTLS_KX_ANON_DH, GNUTLS_KX_RSA, 0 };
int cipher_priority[16] = { GNUTLS_CIPHER_AES_128_CBC, GNUTLS_CIPHER_AES_256_CBC, 0 };
int mac_priority[16] = { GNUTLS_MAC_SHA1, GNUTLS_MAC_MD5, 0 };
......@@ -687,30 +737,38 @@ iphone_error_t lockdownd_start_SSL_session(iphone_lckd_client_t control, const c
gnutls_cipher_set_priority(*control->ssl_session, cipher_priority);
gnutls_compression_set_priority(*control->ssl_session, comp_priority);
gnutls_kx_set_priority(*control->ssl_session, kx_priority);
gnutls_protocol_set_priority( *control->ssl_session, protocol_priority);
gnutls_protocol_set_priority(*control->ssl_session, protocol_priority);
gnutls_mac_set_priority(*control->ssl_session, mac_priority);
}
gnutls_credentials_set(*control->ssl_session, GNUTLS_CRD_CERTIFICATE, xcred); // this part is killing me.
if (debug) printf("GnuTLS step 1...\n");
if (debug)
printf("GnuTLS step 1...\n");
gnutls_transport_set_ptr(*control->ssl_session, (gnutls_transport_ptr_t) control);
if (debug) printf("GnuTLS step 2...\n");
gnutls_transport_set_push_function(*control->ssl_session, (gnutls_push_func)&lockdownd_secuwrite);
if (debug) printf("GnuTLS step 3...\n");
gnutls_transport_set_pull_function(*control->ssl_session, (gnutls_pull_func)&lockdownd_securead);
if (debug) printf("GnuTLS step 4 -- now handshaking...\n");
if (errno && debug) printf("WARN: errno says %s before handshake!\n", strerror(errno));
if (debug)
printf("GnuTLS step 2...\n");
gnutls_transport_set_push_function(*control->ssl_session, (gnutls_push_func) & lockdownd_secuwrite);
if (debug)
printf("GnuTLS step 3...\n");
gnutls_transport_set_pull_function(*control->ssl_session, (gnutls_pull_func) & lockdownd_securead);
if (debug)
printf("GnuTLS step 4 -- now handshaking...\n");
if (errno && debug)
printf("WARN: errno says %s before handshake!\n", strerror(errno));
return_me = gnutls_handshake(*control->ssl_session);
if (debug) printf("GnuTLS handshake done...\n");
if (debug)
printf("GnuTLS handshake done...\n");
free_dictionary(dictionary);
if (return_me != GNUTLS_E_SUCCESS) {
if (debug) printf("GnuTLS reported something wrong.\n");
if (debug)
printf("GnuTLS reported something wrong.\n");
gnutls_perror(return_me);
if (debug) printf("oh.. errno says %s\n", strerror(errno));
if (debug)
printf("oh.. errno says %s\n", strerror(errno));
return IPHONE_E_SSL_ERROR;
} else {
control->in_SSL = 1;
......@@ -722,15 +780,16 @@ iphone_error_t lockdownd_start_SSL_session(iphone_lckd_client_t control, const c
if (debug) {
printf("Apparently failed negotiating with lockdownd.\n");
printf("Responding dictionary: \n");
for (i = 0; dictionary[i]; i+=2) {
printf("\t%s: %s\n", dictionary[i], dictionary[i+1]);
for (i = 0; dictionary[i]; i += 2) {
printf("\t%s: %s\n", dictionary[i], dictionary[i + 1]);
}
}
free_dictionary(dictionary);
return IPHONE_E_SSL_ERROR;
} else {
if (debug) printf("Didn't get enough bytes.\n");
if (debug)
printf("Didn't get enough bytes.\n");
return IPHONE_E_NOT_ENOUGH_DATA;
}
}
......@@ -743,14 +802,18 @@ iphone_error_t lockdownd_start_SSL_session(iphone_lckd_client_t control, const c
*
* @return The number of bytes sent
*/
ssize_t lockdownd_secuwrite(gnutls_transport_ptr_t transport, char *buffer, size_t length) {
ssize_t lockdownd_secuwrite(gnutls_transport_ptr_t transport, char *buffer, size_t length)
{
int bytes = 0;
iphone_lckd_client_t control;
control = (iphone_lckd_client_t)transport;
if (debug) printf("lockdownd_secuwrite() called\n");
if (debug) printf("pre-send\nlength = %zi\n", length);
control = (iphone_lckd_client_t) transport;
if (debug)
printf("lockdownd_secuwrite() called\n");
if (debug)
printf("pre-send\nlength = %zi\n", length);
iphone_mux_send(control->connection, buffer, length, &bytes);
if (debug) printf("post-send\nsent %i bytes\n", bytes);
if (debug)
printf("post-send\nsent %i bytes\n", bytes);
if (debug) {
FILE *my_ssl_packet = fopen("sslpacketwrite.out", "w+");
fwrite(buffer, 1, length, my_ssl_packet);
......@@ -770,12 +833,14 @@ ssize_t lockdownd_secuwrite(gnutls_transport_ptr_t transport, char *buffer, size
*
* @return The number of bytes read
*/
ssize_t lockdownd_securead(gnutls_transport_ptr_t transport, char *buffer, size_t length) {
ssize_t lockdownd_securead(gnutls_transport_ptr_t transport, char *buffer, size_t length)
{
int bytes = 0, pos_start_fill = 0;
char *hackhackhack = NULL;
iphone_lckd_client_t control;
control = (iphone_lckd_client_t)transport;
if (debug) printf("lockdownd_securead() called\nlength = %zi\n", length);
control = (iphone_lckd_client_t) transport;
if (debug)
printf("lockdownd_securead() called\nlength = %zi\n", length);
// Buffering hack! Throw what we've got in our "buffer" into the stream first, then get more.
if (control->gtls_buffer_hack_len > 0) {
if (length > control->gtls_buffer_hack_len) { // If it's asking for more than we got
......@@ -784,54 +849,70 @@ ssize_t lockdownd_securead(gnutls_transport_ptr_t transport, char *buffer, size_
memcpy(buffer, control->gtls_buffer_hack, control->gtls_buffer_hack_len); // Fill their buffer partially
free(control->gtls_buffer_hack); // free our memory, it's not chained anymore
control->gtls_buffer_hack_len = 0; // we don't have a hack buffer anymore
if (debug) printf("Did a partial fill to help quench thirst for data\n");
if (debug)
printf("Did a partial fill to help quench thirst for data\n");
} else if (length < control->gtls_buffer_hack_len) { // If it's asking for less...
control->gtls_buffer_hack_len -= length; // subtract what they're asking for
memcpy(buffer, control->gtls_buffer_hack, length); // fill their buffer
hackhackhack = (char*)malloc(sizeof(char) * control->gtls_buffer_hack_len); // strndup is NOT a good solution -- concatenates \0!!!! Anyway, make a new "hack" buffer.
memcpy(hackhackhack, control->gtls_buffer_hack+length, control->gtls_buffer_hack_len); // Move what's left into the new one
hackhackhack = (char *) malloc(sizeof(char) * control->gtls_buffer_hack_len); // strndup is NOT a good solution -- concatenates \0!!!! Anyway, make a new "hack" buffer.
memcpy(hackhackhack, control->gtls_buffer_hack + length, control->gtls_buffer_hack_len); // Move what's left into the new one
free(control->gtls_buffer_hack); // Free the old one
control->gtls_buffer_hack = hackhackhack; // And make it the new one.
hackhackhack = NULL;
if (debug) printf("Quenched the thirst for data; new hack length is %i\n", control->gtls_buffer_hack_len);
if (debug)
printf("Quenched the thirst for data; new hack length is %i\n", control->gtls_buffer_hack_len);
return length; // hand it over.
} else { // length == hack length
memcpy(buffer, control->gtls_buffer_hack, length); // copy our buffer into theirs
free(control->gtls_buffer_hack); // free our "obligation"
control->gtls_buffer_hack_len = 0; // free our "obligation"
if (debug) printf("Satiated the thirst for data; now we have to eventually receive again.\n");
if (debug)
printf("Satiated the thirst for data; now we have to eventually receive again.\n");
return length; // hand it over
}
}
// End buffering hack!
char *recv_buffer = (char*)malloc(sizeof(char) * (length * 1000)); // ensuring nothing stupid happens
char *recv_buffer = (char *) malloc(sizeof(char) * (length * 1000)); // ensuring nothing stupid happens
if (debug) printf("pre-read\nclient wants %zi bytes\n", length);
if (debug)
printf("pre-read\nclient wants %zi bytes\n", length);
iphone_mux_recv(control->connection, recv_buffer, (length * 1000), &bytes);
if (debug) printf("post-read\nwe got %i bytes\n", bytes);
if (debug)
printf("post-read\nwe got %i bytes\n", bytes);
if (debug && bytes < 0) {
printf("lockdownd_securead(): uh oh\n");
printf("I believe what we have here is a failure to communicate... libusb says %s but strerror says %s\n", usb_strerror(), strerror(errno));
printf("I believe what we have here is a failure to communicate... libusb says %s but strerror says %s\n",
usb_strerror(), strerror(errno));
return bytes + 28; // an errno
}
if (bytes >= length) {
if (bytes > length) {
if (debug) printf("lockdownd_securead: Client deliberately read less data than was there; resorting to GnuTLS buffering hack.\n");
if (debug)
printf
("lockdownd_securead: Client deliberately read less data than was there; resorting to GnuTLS buffering hack.\n");
if (!control->gtls_buffer_hack_len) { // if there's no hack buffer yet
//control->gtls_buffer_hack = strndup(recv_buffer+length, bytes-length); // strndup is NOT a good solution!
control->gtls_buffer_hack_len += bytes-length;
control->gtls_buffer_hack = (char*)malloc(sizeof(char) * control->gtls_buffer_hack_len);
memcpy(control->gtls_buffer_hack, recv_buffer+length, control->gtls_buffer_hack_len);
control->gtls_buffer_hack_len += bytes - length;
control->gtls_buffer_hack = (char *) malloc(sizeof(char) * control->gtls_buffer_hack_len);
memcpy(control->gtls_buffer_hack, recv_buffer + length, control->gtls_buffer_hack_len);
} else { // if there is.
control->gtls_buffer_hack = realloc(control->gtls_buffer_hack, control->gtls_buffer_hack_len + (bytes - length));
memcpy(control->gtls_buffer_hack+control->gtls_buffer_hack_len, recv_buffer+length, bytes-length);
control->gtls_buffer_hack =
realloc(control->gtls_buffer_hack, control->gtls_buffer_hack_len + (bytes - length));
memcpy(control->gtls_buffer_hack + control->gtls_buffer_hack_len, recv_buffer + length, bytes - length);
control->gtls_buffer_hack_len += bytes - length;
}
}
memcpy(buffer+pos_start_fill, recv_buffer, length);
memcpy(buffer + pos_start_fill, recv_buffer, length);
free(recv_buffer);
if (bytes == length) { if (debug) printf("Returning how much we received.\n"); return bytes; }
else { if (debug) printf("Returning what they want to hear.\nHack length: %i\n", control->gtls_buffer_hack_len); return length; }
if (bytes == length) {
if (debug)
printf("Returning how much we received.\n");
return bytes;
} else {
if (debug)
printf("Returning what they want to hear.\nHack length: %i\n", control->gtls_buffer_hack_len);
return length;
}
}
return bytes;
}
......@@ -843,12 +924,16 @@ ssize_t lockdownd_securead(gnutls_transport_ptr_t transport, char *buffer, size_
*
* @return The port number the service was started on or 0 on failure.
*/
iphone_error_t iphone_lckd_start_service ( iphone_lckd_client_t client, const char *service, int *port ) {
if (!client || !service || !port) return IPHONE_E_INVALID_ARG;
iphone_error_t iphone_lckd_start_service(iphone_lckd_client_t client, const char *service, int *port)
{
if (!client || !service || !port)
return IPHONE_E_INVALID_ARG;
char* host_id = get_host_id();
if (!host_id) return IPHONE_E_INVALID_CONF;
if (!client->in_SSL && !lockdownd_start_SSL_session(client, host_id)) return IPHONE_E_SSL_ERROR;
char *host_id = get_host_id();
if (!host_id)
return IPHONE_E_INVALID_CONF;
if (!client->in_SSL && !lockdownd_start_SSL_session(client, host_id))
return IPHONE_E_SSL_ERROR;
char *XML_query, **dictionary;
uint32 length, i = 0, port_loc = 0, bytes = 0;
......@@ -862,43 +947,58 @@ iphone_error_t iphone_lckd_start_service ( iphone_lckd_client_t client, const ch
xmlNode *dict = add_child_to_plist(plist, "dict", "\n", NULL, 0);
xmlNode *key;
key = add_key_str_dict_element(plist, dict, "Request", "StartService", 1);
if (!key) { xmlFreeDoc(plist); return IPHONE_E_UNKNOWN_ERROR; }
if (!key) {
xmlFreeDoc(plist);
return IPHONE_E_UNKNOWN_ERROR;
}
key = add_key_str_dict_element(plist, dict, "Service", service, 1);
if (!key) { xmlFreeDoc(plist); return IPHONE_E_UNKNOWN_ERROR; }
if (!key) {
xmlFreeDoc(plist);
return IPHONE_E_UNKNOWN_ERROR;
}
xmlDocDumpMemory(plist, (xmlChar **)&XML_query, &length);
xmlDocDumpMemory(plist, (xmlChar **) & XML_query, &length);
ret = iphone_lckd_send(client, XML_query, length, &bytes);
free(XML_query);
if (IPHONE_E_SUCCESS != ret) return ret;
if (IPHONE_E_SUCCESS != ret)
return ret;
ret = iphone_lckd_recv(client, &XML_query, &bytes);
xmlFreeDoc(plist);
if (IPHONE_E_SUCCESS != ret) return ret;
if (IPHONE_E_SUCCESS != ret)
return ret;
if (bytes <= 0) return IPHONE_E_NOT_ENOUGH_DATA;
if (bytes <= 0)
return IPHONE_E_NOT_ENOUGH_DATA;
else {
plist = xmlReadMemory(XML_query, bytes, NULL, NULL, 0);
if (!plist) return IPHONE_E_UNKNOWN_ERROR;
if (!plist)
return IPHONE_E_UNKNOWN_ERROR;
dict = xmlDocGetRootElement(plist);
if (!dict) return IPHONE_E_UNKNOWN_ERROR;
if (!dict)
return IPHONE_E_UNKNOWN_ERROR;
for (dict = dict->children; dict; dict = dict->next) {
if (!xmlStrcmp(dict->name, "dict")) break;
if (!xmlStrcmp(dict->name, "dict"))
break;
}
if (!dict) return IPHONE_E_UNKNOWN_ERROR;
if (!dict)
return IPHONE_E_UNKNOWN_ERROR;
dictionary = read_dict_element_strings(dict);
for (i = 0; dictionary[i]; i+=2) {
if (debug) printf("lockdownd_start_service() dictionary %s: %s\n", dictionary[i], dictionary[i+1]);
for (i = 0; dictionary[i]; i += 2) {
if (debug)
printf("lockdownd_start_service() dictionary %s: %s\n", dictionary[i], dictionary[i + 1]);
if (!xmlStrcmp(dictionary[i], "Port")) {
port_loc = atoi(dictionary[i+1]);
if (debug) printf("lockdownd_start_service() atoi'd port: %i\n", port);
port_loc = atoi(dictionary[i + 1]);
if (debug)
printf("lockdownd_start_service() atoi'd port: %i\n", port);
}
if (!xmlStrcmp(dictionary[i], "Result")) {
if (!xmlStrcmp(dictionary[i+1], "Success")) {
if (!xmlStrcmp(dictionary[i + 1], "Success")) {
result = 1;
}
}
......@@ -916,8 +1016,8 @@ iphone_error_t iphone_lckd_start_service ( iphone_lckd_client_t client, const ch
if (port && result) {
*port = port_loc;
return IPHONE_E_SUCCESS;
}
else return IPHONE_E_UNKNOWN_ERROR;
} else
return IPHONE_E_UNKNOWN_ERROR;
}
return IPHONE_E_UNKNOWN_ERROR;
......
......@@ -47,7 +47,8 @@ iphone_error_t lockdownd_hello(iphone_lckd_client_t control);
iphone_error_t lockdownd_get_device_uid(iphone_lckd_client_t control, char **uid);
iphone_error_t lockdownd_get_device_public_key(iphone_lckd_client_t control, char **public_key);
iphone_error_t lockdownd_gen_pair_cert(char *public_key_b64, char **device_cert_b64, char **host_cert_b64, char **root_cert_b64);
iphone_error_t lockdownd_gen_pair_cert(char *public_key_b64, char **device_cert_b64, char **host_cert_b64,
char **root_cert_b64);
iphone_error_t lockdownd_pair_device(iphone_lckd_client_t control, char *public_key, char *host_id);
void lockdownd_close(iphone_lckd_client_t control);
......
......@@ -34,12 +34,13 @@
int debug = 1;
int main(int argc, char *argv[]) {
int main(int argc, char *argv[])
{
int bytes = 0, port = 0, i = 0;
iphone_lckd_client_t control = NULL;
iphone_device_t phone = NULL;
if (argc > 1 && !strcasecmp(argv[1], "--debug")){
if (argc > 1 && !strcasecmp(argv[1], "--debug")) {
debug = 1;
} else {
debug = 0;
......@@ -50,7 +51,7 @@ int main(int argc, char *argv[]) {
return -1;
}
if (IPHONE_E_SUCCESS != iphone_lckd_new_client(phone, &control)){
if (IPHONE_E_SUCCESS != iphone_lckd_new_client(phone, &control)) {
iphone_free_device(phone);
return -1;
}
......@@ -69,7 +70,8 @@ int main(int argc, char *argv[]) {
if (afc) {
char **dirs = NULL;
iphone_afc_get_dir_list(afc, "/eafaedf", &dirs);
if (!dirs) iphone_afc_get_dir_list(afc, "/", &dirs);
if (!dirs)
iphone_afc_get_dir_list(afc, "/", &dirs);
printf("Directory time.\n");
for (i = 0; dirs[i]; i++) {
printf("/%s\n", dirs[i]);
......@@ -78,18 +80,19 @@ int main(int argc, char *argv[]) {
g_strfreev(dirs);
iphone_afc_get_devinfo(afc, &dirs);
if (dirs) {
for (i = 0; dirs[i]; i+=2) {
printf("%s: %s\n", dirs[i], dirs[i+1]);
for (i = 0; dirs[i]; i += 2) {
printf("%s: %s\n", dirs[i], dirs[i + 1]);
}
}
g_strfreev(dirs);
iphone_afc_file_t my_file = NULL;
struct stat stbuf;
iphone_afc_get_file_attr ( afc, "/iTunesOnTheGoPlaylist.plist", &stbuf );
if (IPHONE_E_SUCCESS == iphone_afc_open_file(afc, "/iTunesOnTheGoPlaylist.plist", IPHONE_AFC_FILE_READ, &my_file) && my_file) {
iphone_afc_get_file_attr(afc, "/iTunesOnTheGoPlaylist.plist", &stbuf);
if (IPHONE_E_SUCCESS ==
iphone_afc_open_file(afc, "/iTunesOnTheGoPlaylist.plist", IPHONE_AFC_FILE_READ, &my_file) && my_file) {
printf("A file size: %i\n", stbuf.st_size);
char *file_data = (char*)malloc(sizeof(char) * stbuf.st_size);
char *file_data = (char *) malloc(sizeof(char) * stbuf.st_size);
iphone_afc_read_file(afc, my_file, file_data, stbuf.st_size, &bytes);
if (bytes >= 0) {
printf("The file's data:\n");
......@@ -98,35 +101,45 @@ int main(int argc, char *argv[]) {
printf("\nClosing my file.\n");
iphone_afc_close_file(afc, my_file);
free(file_data);
} else printf("couldn't open a file\n");
} else
printf("couldn't open a file\n");
iphone_afc_open_file(afc, "/readme.libiphone.fx", IPHONE_AFC_FILE_WRITE, &my_file);
if (my_file) {
char *outdatafile = strdup("this is a bitchin text file\n");
iphone_afc_write_file(afc, my_file, outdatafile, strlen(outdatafile), &bytes);
free(outdatafile);
if (bytes > 0) printf("Wrote a surprise. ;)\n");
else printf("I wanted to write a surprise, but... :(\n");
if (bytes > 0)
printf("Wrote a surprise. ;)\n");
else
printf("I wanted to write a surprise, but... :(\n");
iphone_afc_close_file(afc, my_file);
}
printf("Deleting a file...\n");
bytes = iphone_afc_delete_file(afc, "/delme");
if (bytes) printf("Success.\n");
else printf("Failure. (expected unless you have a /delme file on your phone)\n");
if (bytes)
printf("Success.\n");
else
printf("Failure. (expected unless you have a /delme file on your phone)\n");
printf("Renaming a file...\n");
bytes = iphone_afc_rename_file(afc, "/renme", "/renme2");
if (bytes > 0) printf("Success.\n");
else printf("Failure. (expected unless you have a /renme file on your phone)\n");
if (bytes > 0)
printf("Success.\n");
else
printf("Failure. (expected unless you have a /renme file on your phone)\n");
printf("Seek & read\n");
iphone_afc_open_file(afc, "/readme.libiphone.fx", IPHONE_AFC_FILE_READ, &my_file);
if (IPHONE_E_SUCCESS != iphone_afc_seek_file(afc, my_file, 5)) printf("WARN: SEEK DID NOT WORK\n");
char *threeletterword = (char*)malloc(sizeof(char) * 5);
if (IPHONE_E_SUCCESS != iphone_afc_seek_file(afc, my_file, 5))
printf("WARN: SEEK DID NOT WORK\n");
char *threeletterword = (char *) malloc(sizeof(char) * 5);
iphone_afc_read_file(afc, my_file, threeletterword, 3, &bytes);
threeletterword[3] = '\0';
if (bytes > 0) printf("Result: %s\n", threeletterword);
else printf("Couldn't read!\n");
if (bytes > 0)
printf("Result: %s\n", threeletterword);
else
printf("Couldn't read!\n");
free(threeletterword);
iphone_afc_close_file(afc, my_file);
......@@ -143,4 +156,3 @@ int main(int argc, char *argv[]) {
return 0;
}
......@@ -40,12 +40,12 @@ const char *plist_base = "<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n\
*
* @return The formatted string.
*/
char* format_string(const char* buf, int cols, int depth)
char *format_string(const char *buf, int cols, int depth)
{
int colw = depth + cols + 1;
int len = strlen(buf);
int nlines = len / cols + 1;
char* new_buf = (char*)malloc(nlines * colw + depth + 1);
char *new_buf = (char *) malloc(nlines * colw + depth + 1);
int i = 0;
int j = 0;
......@@ -53,18 +53,18 @@ char* format_string(const char* buf, int cols, int depth)
assert(depth >= 0);
// Inserts new lines and tabs at appropriate locations
for (i = 0; i < nlines; i++){
for (i = 0; i < nlines; i++) {
new_buf[i * colw] = '\n';
for (j = 0; j < depth; j++)
new_buf[i * colw + 1 + j] = '\t';
memcpy(new_buf + i * colw + 1 + depth, buf + i * cols, cols);
}
new_buf[len+(1+depth)*nlines] = '\n';
new_buf[len + (1 + depth) * nlines] = '\n';
// Inserts final row of indentation and termination character
for (j = 0; j < depth; j++)
new_buf[len+(1+depth)*nlines + 1 + j] = '\t';
new_buf[len+(1+depth)*nlines+depth+1] = '\0';
new_buf[len + (1 + depth) * nlines + 1 + j] = '\t';
new_buf[len + (1 + depth) * nlines + depth + 1] = '\0';
return new_buf;
}
......@@ -73,11 +73,13 @@ char* format_string(const char* buf, int cols, int depth)
*
* @return The plist XML document.
*/
xmlDocPtr new_plist() {
xmlDocPtr new_plist()
{
char *plist = strdup(plist_base);
xmlDocPtr plist_xml = xmlReadMemory(plist, strlen(plist), NULL, NULL, 0);
if (!plist_xml) return NULL;
if (!plist_xml)
return NULL;
free(plist);
......@@ -88,8 +90,10 @@ xmlDocPtr new_plist() {
*
* @param plist The XML document to destroy.
*/
void free_plist(xmlDocPtr plist) {
if (!plist) return;
void free_plist(xmlDocPtr plist)
{
if (!plist)
return;
xmlFreeDoc(plist);
}
......@@ -109,13 +113,16 @@ void free_plist(xmlDocPtr plist) {
*
* @return The newly created node.
*/
xmlNode *add_child_to_plist(xmlDocPtr plist, const char *name, const char *content, xmlNode *to_node, int depth) {
xmlNode *add_child_to_plist(xmlDocPtr plist, const char *name, const char *content, xmlNode * to_node, int depth)
{
int i = 0;
xmlNode *child;
if (!plist) return NULL;
if (!plist)
return NULL;
assert(depth >= 0);
if (!to_node) to_node = xmlDocGetRootElement(plist);
if (!to_node)
to_node = xmlDocGetRootElement(plist);
for (i = 0; i < depth; i++) {
xmlNodeAddContent(to_node, "\t");
......@@ -136,7 +143,8 @@ xmlNode *add_child_to_plist(xmlDocPtr plist, const char *name, const char *conte
*
* @return The newly created key node.
*/
xmlNode *add_key_str_dict_element(xmlDocPtr plist, xmlNode *dict, const char *key, const char *value, int depth) {
xmlNode *add_key_str_dict_element(xmlDocPtr plist, xmlNode * dict, const char *key, const char *value, int depth)
{
xmlNode *keyPtr;
keyPtr = add_child_to_plist(plist, "key", key, dict, depth);
......@@ -155,7 +163,8 @@ xmlNode *add_key_str_dict_element(xmlDocPtr plist, xmlNode *dict, const char *ke
*
* @return The newly created dict node.
*/
xmlNode *add_key_dict_node(xmlDocPtr plist, xmlNode *dict, const char *key, const char *value, int depth) {
xmlNode *add_key_dict_node(xmlDocPtr plist, xmlNode * dict, const char *key, const char *value, int depth)
{
xmlNode *child;
add_child_to_plist(plist, "key", key, dict, depth);
......@@ -174,7 +183,8 @@ xmlNode *add_key_dict_node(xmlDocPtr plist, xmlNode *dict, const char *key, cons
*
* @return The newly created key node.
*/
xmlNode *add_key_data_dict_element(xmlDocPtr plist, xmlNode *dict, const char *key, const char *value, int depth) {
xmlNode *add_key_data_dict_element(xmlDocPtr plist, xmlNode * dict, const char *key, const char *value, int depth)
{
xmlNode *keyPtr;
keyPtr = add_child_to_plist(plist, "key", key, dict, depth);
......@@ -190,7 +200,8 @@ xmlNode *add_key_data_dict_element(xmlDocPtr plist, xmlNode *dict, const char *k
* @return An array where each even number is a key and the odd numbers are
* values. If the odd number is \0, that's the end of the list.
*/
char **read_dict_element_strings(xmlNode *dict) {
char **read_dict_element_strings(xmlNode * dict)
{
char **return_me = NULL, **old = NULL;
int current_length = 0;
int current_pos = 0;
......@@ -200,7 +211,7 @@ char **read_dict_element_strings(xmlNode *dict) {
if (!xmlStrcmp(dict_walker->name, "key")) {
current_length += 2;
old = return_me;
return_me = realloc(return_me, sizeof(char*) * current_length);
return_me = realloc(return_me, sizeof(char *) * current_length);
if (!return_me) {
free(old);
return NULL;
......@@ -211,7 +222,7 @@ char **read_dict_element_strings(xmlNode *dict) {
}
old = return_me;
return_me = realloc(return_me, sizeof(char*) * (current_length+1));
return_me = realloc(return_me, sizeof(char *) * (current_length + 1));
return_me[current_pos] = NULL;
return return_me;
......@@ -219,10 +230,12 @@ char **read_dict_element_strings(xmlNode *dict) {
/** Destroys a dictionary as returned by read_dict_element_strings
*/
void free_dictionary(char **dictionary) {
void free_dictionary(char **dictionary)
{
int i = 0;
if (!dictionary) return;
if (!dictionary)
return;
for (i = 0; dictionary[i]; i++) {
free(dictionary[i]);
......@@ -230,4 +243,3 @@ void free_dictionary(char **dictionary) {
free(dictionary);
}
......@@ -25,14 +25,14 @@
#include <libxml/parser.h>
#include <libxml/tree.h>
xmlNode *add_key_dict_node(xmlDocPtr plist, xmlNode *dict, const char *key, const char *value, int depth);
xmlNode *add_key_str_dict_element(xmlDocPtr plist, xmlNode *dict, const char *key, const char *value, int depth);
xmlNode *add_key_data_dict_element(xmlDocPtr plist, xmlNode *dict, const char *key, const char *value, int depth);
xmlNode *add_child_to_plist(xmlDocPtr plist, const char *name, const char *content, xmlNode *to_node, int depth);
xmlNode *add_key_dict_node(xmlDocPtr plist, xmlNode * dict, const char *key, const char *value, int depth);
xmlNode *add_key_str_dict_element(xmlDocPtr plist, xmlNode * dict, const char *key, const char *value, int depth);
xmlNode *add_key_data_dict_element(xmlDocPtr plist, xmlNode * dict, const char *key, const char *value, int depth);
xmlNode *add_child_to_plist(xmlDocPtr plist, const char *name, const char *content, xmlNode * to_node, int depth);
void free_plist(xmlDocPtr plist);
xmlDocPtr new_plist();
char **read_dict_element_strings(xmlNode *dict);
char **read_dict_element_strings(xmlNode * dict);
void free_dictionary(char **dictionary);
#endif
......@@ -39,8 +39,9 @@ static int clients = 0;
*
* @return A USBMux packet
*/
usbmux_tcp_header *new_mux_packet(uint16 s_port, uint16 d_port) {
usbmux_tcp_header *conn = (usbmux_tcp_header*)malloc(sizeof(usbmux_tcp_header));
usbmux_tcp_header *new_mux_packet(uint16 s_port, uint16 d_port)
{
usbmux_tcp_header *conn = (usbmux_tcp_header *) malloc(sizeof(usbmux_tcp_header));
conn->type = htonl(6);
conn->length = 28;
conn->sport = htons(s_port);
......@@ -58,8 +59,9 @@ usbmux_tcp_header *new_mux_packet(uint16 s_port, uint16 d_port) {
*
* @return A USBMux header
*/
usbmux_version_header *version_header() {
usbmux_version_header *version = (usbmux_version_header*)malloc(sizeof(usbmux_version_header));
usbmux_version_header *version_header()
{
usbmux_version_header *version = (usbmux_version_header *) malloc(sizeof(usbmux_version_header));
version->type = 0;
version->length = htonl(20);
version->major = htonl(1);
......@@ -76,11 +78,13 @@ usbmux_version_header *version_header() {
*
* @param connection The connection to delete from the tracking list.
*/
void delete_connection(iphone_umux_client_t connection) {
iphone_umux_client_t *newlist = (iphone_umux_client_t*)malloc(sizeof(iphone_umux_client_t) * (clients - 1));
void delete_connection(iphone_umux_client_t connection)
{
iphone_umux_client_t *newlist = (iphone_umux_client_t *) malloc(sizeof(iphone_umux_client_t) * (clients - 1));
int i = 0, j = 0;
for (i = 0; i < clients; i++) {
if (connlist[i] == connection) continue;
if (connlist[i] == connection)
continue;
else {
newlist[j] = connlist[i];
j++;
......@@ -89,8 +93,10 @@ void delete_connection(iphone_umux_client_t connection) {
free(connlist);
connlist = newlist;
clients--;
if (connection->recv_buffer) free(connection->recv_buffer);
if (connection->header) free(connection->header);
if (connection->recv_buffer)
free(connection->recv_buffer);
if (connection->header)
free(connection->header);
connection->r_len = 0;
free(connection);
}
......@@ -101,8 +107,10 @@ void delete_connection(iphone_umux_client_t connection) {
* @param connection The connection to add to the global list of connections.
*/
void add_connection(iphone_umux_client_t connection) {
iphone_umux_client_t* newlist = (iphone_umux_client_t*)realloc(connlist, sizeof(iphone_umux_client_t) * (clients+1));
void add_connection(iphone_umux_client_t connection)
{
iphone_umux_client_t *newlist =
(iphone_umux_client_t *) realloc(connlist, sizeof(iphone_umux_client_t) * (clients + 1));
newlist[clients] = connection;
connlist = newlist;
clients++;
......@@ -116,13 +124,15 @@ void add_connection(iphone_umux_client_t connection) {
* @param client A mux TCP header for the connection which is used for tracking and data transfer.
* @return IPHONE_E_SUCCESS on success, an error code otherwise.
*/
iphone_error_t iphone_mux_new_client ( iphone_device_t device, uint16_t src_port, uint16_t dst_port, iphone_umux_client_t *client ){
iphone_error_t iphone_mux_new_client(iphone_device_t device, uint16_t src_port, uint16_t dst_port,
iphone_umux_client_t * client)
{
if (!device || !src_port || !dst_port)
return IPHONE_E_INVALID_ARG;
int bytes = 0;
// Initialize connection stuff
iphone_umux_client_t new_connection = (iphone_umux_client_t)malloc(sizeof(struct iphone_umux_client_int));
iphone_umux_client_t new_connection = (iphone_umux_client_t) malloc(sizeof(struct iphone_umux_client_int));
new_connection->header = new_mux_packet(src_port, dst_port);
// blargg
......@@ -131,17 +141,18 @@ iphone_error_t iphone_mux_new_client ( iphone_device_t device, uint16_t src_port
new_connection->header->length = htonl(new_connection->header->length);
new_connection->header->length16 = htons(new_connection->header->length16);
if (send_to_phone(device, (char*)new_connection->header, sizeof(usbmux_tcp_header)) >= 0) {
if (send_to_phone(device, (char *) new_connection->header, sizeof(usbmux_tcp_header)) >= 0) {
usbmux_tcp_header *response;
response = (usbmux_tcp_header*)malloc(sizeof(usbmux_tcp_header));
bytes = recv_from_phone(device, (char*)response, sizeof(*response));
response = (usbmux_tcp_header *) malloc(sizeof(usbmux_tcp_header));
bytes = recv_from_phone(device, (char *) response, sizeof(*response));
if (response->tcp_flags != 0x12) {
free(response);
return IPHONE_E_UNKNOWN_ERROR;
} else {
free(response);
if (debug) printf("mux_connect: connection success\n");
if (debug)
printf("mux_connect: connection success\n");
new_connection->header->tcp_flags = 0x10;
new_connection->header->scnt = 1;
new_connection->header->ocnt = 1;
......@@ -156,7 +167,6 @@ iphone_error_t iphone_mux_new_client ( iphone_device_t device, uint16_t src_port
return IPHONE_E_NOT_ENOUGH_DATA;
}
}
// if we get to this point it's probably bad
return IPHONE_E_UNKNOWN_ERROR;
}
......@@ -168,20 +178,22 @@ iphone_error_t iphone_mux_new_client ( iphone_device_t device, uint16_t src_port
*
* @return IPHONE_E_SUCCESS on success.
*/
iphone_error_t iphone_mux_free_client ( iphone_umux_client_t client ) {
if (!client || !client->phone) return;
iphone_error_t iphone_mux_free_client(iphone_umux_client_t client)
{
if (!client || !client->phone)
return;
client->header->tcp_flags = 0x04;
client->header->scnt = htonl(client->header->scnt);
client->header->ocnt = htonl(client->header->ocnt);
int bytes = 0;
bytes = usb_bulk_write(client->phone->device, BULKOUT, (char*)client->header, sizeof(usbmux_tcp_header), 800);
if(debug && bytes < 0)
bytes = usb_bulk_write(client->phone->device, BULKOUT, (char *) client->header, sizeof(usbmux_tcp_header), 800);
if (debug && bytes < 0)
printf("iphone_muxèfree_client(): when writing, libusb gave me the error: %s\n", usb_strerror());
bytes = usb_bulk_read(client->phone->device, BULKIN, (char*)client->header, sizeof(usbmux_tcp_header), 800);
if(debug && bytes < 0)
bytes = usb_bulk_read(client->phone->device, BULKIN, (char *) client->header, sizeof(usbmux_tcp_header), 800);
if (debug && bytes < 0)
printf("get_iPhone(): when reading, libusb gave me the error: %s\n", usb_strerror());
delete_connection(client);
......@@ -201,13 +213,16 @@ iphone_error_t iphone_mux_free_client ( iphone_umux_client_t client ) {
* @return IPHONE_E_SUCCESS on success.
*/
iphone_error_t iphone_mux_send ( iphone_umux_client_t client, const char *data, uint32_t datalen, uint32_t *sent_bytes ) {
if (!client->phone || !client || !data || datalen == 0 || !sent_bytes) return IPHONE_E_INVALID_ARG;
iphone_error_t iphone_mux_send(iphone_umux_client_t client, const char *data, uint32_t datalen, uint32_t * sent_bytes)
{
if (!client->phone || !client || !data || datalen == 0 || !sent_bytes)
return IPHONE_E_INVALID_ARG;
// client->scnt and client->ocnt should already be in host notation...
// we don't need to change them juuuust yet.
*sent_bytes = 0;
if (debug) printf("mux_send(): client wants to send %i bytes\n", datalen);
char *buffer = (char*)malloc(sizeof(usbmux_tcp_header) + datalen + 2); // allow 2 bytes of safety padding
if (debug)
printf("mux_send(): client wants to send %i bytes\n", datalen);
char *buffer = (char *) malloc(sizeof(usbmux_tcp_header) + datalen + 2); // allow 2 bytes of safety padding
// Set the length and pre-emptively htonl/htons it
client->header->length = htonl(sizeof(usbmux_tcp_header) + datalen);
client->header->length16 = htons(sizeof(usbmux_tcp_header) + datalen);
......@@ -217,14 +232,16 @@ iphone_error_t iphone_mux_send ( iphone_umux_client_t client, const char *data,
client->header->ocnt = htonl(client->header->ocnt);
// Concatenation of stuff in the buffer.
memcpy(buffer, client->header, sizeof(usbmux_tcp_header));
memcpy(buffer+sizeof(usbmux_tcp_header), data, datalen);
memcpy(buffer + sizeof(usbmux_tcp_header), data, datalen);
// We have a buffer full of data, we should now send it to the phone.
if (debug) printf("actually sending %zi bytes of data at %p\n", sizeof(usbmux_tcp_header)+datalen, buffer);
if (debug)
printf("actually sending %zi bytes of data at %p\n", sizeof(usbmux_tcp_header) + datalen, buffer);
*sent_bytes = send_to_phone(client->phone, buffer, sizeof(usbmux_tcp_header)+datalen);
if (debug) printf("mux_send: sent %i bytes!\n", *sent_bytes);
*sent_bytes = send_to_phone(client->phone, buffer, sizeof(usbmux_tcp_header) + datalen);
if (debug)
printf("mux_send: sent %i bytes!\n", *sent_bytes);
// Now that we've sent it off, we can clean up after our sloppy selves.
if (debug) {
FILE *packet = fopen("packet", "a+");
......@@ -233,7 +250,8 @@ iphone_error_t iphone_mux_send ( iphone_umux_client_t client, const char *data,
printf("\n");
}
if (buffer) free(buffer);
if (buffer)
free(buffer);
// Re-calculate scnt and ocnt
client->header->scnt = ntohl(client->header->scnt) + datalen;
client->header->ocnt = ntohl(client->header->ocnt);
......@@ -243,7 +261,7 @@ iphone_error_t iphone_mux_send ( iphone_umux_client_t client, const char *data,
client->header->length16 = ntohs(client->header->length16);
// Now return the bytes.
if (*sent_bytes < sizeof(usbmux_tcp_header)+datalen) {
if (*sent_bytes < sizeof(usbmux_tcp_header) + datalen) {
*sent_bytes = 0;
return IPHONE_E_NOT_ENOUGH_DATA;
} else {
......@@ -261,7 +279,8 @@ iphone_error_t iphone_mux_send ( iphone_umux_client_t client, const char *data,
*
* @return How many bytes were read, or -1 if something bad happens.
*/
iphone_error_t iphone_mux_recv ( iphone_umux_client_t client, char *data, uint32_t datalen, uint32_t *recv_bytes ) {
iphone_error_t iphone_mux_recv(iphone_umux_client_t client, char *data, uint32_t datalen, uint32_t * recv_bytes)
{
if (!client || !data || datalen == 0 || !recv_bytes)
return IPHONE_E_INVALID_ARG;
......@@ -275,7 +294,8 @@ iphone_error_t iphone_mux_recv ( iphone_umux_client_t client, char *data, uint32
* a.) Check incoming packet's ports. If proper, follow proper buffering and receiving operation.
* b.) If not, find the client the ports belong to and fill that client's buffer, then return mux_recv with the same args to try again.
*/
if (debug) printf("mux_recv: datalen == %i\n", datalen);
if (debug)
printf("mux_recv: datalen == %i\n", datalen);
int bytes = 0, i = 0, complex = 0, offset = 0;
*recv_bytes = 0;
char *buffer = NULL;
......@@ -290,8 +310,8 @@ iphone_error_t iphone_mux_recv ( iphone_umux_client_t client, char *data, uint32
client->r_len = 0;
client->recv_buffer = NULL;
} else {
buffer = (char*)malloc(sizeof(char) * (client->r_len - datalen));
memcpy(buffer, client->recv_buffer+datalen, (client->r_len - datalen));
buffer = (char *) malloc(sizeof(char) * (client->r_len - datalen));
memcpy(buffer, client->recv_buffer + datalen, (client->r_len - datalen));
client->r_len -= datalen;
free(client->recv_buffer);
client->recv_buffer = buffer;
......@@ -307,24 +327,25 @@ iphone_error_t iphone_mux_recv ( iphone_umux_client_t client, char *data, uint32
}
} // End of what to do if we have a pre-buffer. See #1 and #2 above.
buffer = (char*)malloc(sizeof(char) * 131072); // make sure we get enough ;)
buffer = (char *) malloc(sizeof(char) * 131072); // make sure we get enough ;)
// See #3.
bytes = recv_from_phone(client->phone, buffer, 131072);
if (bytes < 28) {
free(buffer);
if (debug) printf("mux_recv: Did not even get the header.\n");
if (debug)
printf("mux_recv: Did not even get the header.\n");
return IPHONE_E_NOT_ENOUGH_DATA;
}
header = (usbmux_tcp_header*)buffer;
header = (usbmux_tcp_header *) buffer;
if (header->sport != client->header->dport || header->dport != client->header->sport) {
// Ooooops -- we got someone else's packet.
// We gotta stick it in their buffer. (Take that any old way you want ;) )
for (i = 0; i < clients; i++) {
if (connlist[i]->header->sport == header->dport && connlist[i]->header->dport == header->sport) {
// we have a winner.
char *nfb = (char*)malloc(sizeof(char) * (connlist[i]->r_len + (bytes - 28)));
char *nfb = (char *) malloc(sizeof(char) * (connlist[i]->r_len + (bytes - 28)));
if (connlist[i]->recv_buffer && connlist[i]->r_len) {
memcpy(nfb, connlist[i]->recv_buffer, connlist[i]->r_len);
free(connlist[i]->recv_buffer);
......@@ -334,8 +355,8 @@ iphone_error_t iphone_mux_recv ( iphone_umux_client_t client, char *data, uint32
connlist[i]->recv_buffer = nfb;
nfb = NULL; // A cookie for you if you can guess what "nfb" means.
complex = connlist[i]->r_len - (bytes - 28);
memcpy(connlist[i]->recv_buffer+complex, buffer+28, bytes-28); // paste into their buffer
connlist[i]->header->ocnt += bytes-28;
memcpy(connlist[i]->recv_buffer + complex, buffer + 28, bytes - 28); // paste into their buffer
connlist[i]->header->ocnt += bytes - 28;
}
}
// If it wasn't ours, it's been handled by this point... or forgotten.
......@@ -344,33 +365,32 @@ iphone_error_t iphone_mux_recv ( iphone_umux_client_t client, char *data, uint32
buffer = NULL;
return iphone_mux_recv(client, data, datalen, recv_bytes); // recurse back in to try again
}
// The packet was absolutely meant for us if it hits this point.
// The pre-buffer has been taken care of, so, again, if we're at this point we have to read from the phone.
if ((bytes-28) > datalen) {
if ((bytes - 28) > datalen) {
// Copy what we need into the data, buffer the rest because we can.
memcpy(data+offset, buffer+28, datalen); // data+offset: see #2b, above
complex = client->r_len + (bytes-28) - datalen;
client->recv_buffer = (char*)realloc(client->recv_buffer, (sizeof(char) * complex));
memcpy(data + offset, buffer + 28, datalen); // data+offset: see #2b, above
complex = client->r_len + (bytes - 28) - datalen;
client->recv_buffer = (char *) realloc(client->recv_buffer, (sizeof(char) * complex));
client->r_len = complex;
complex = client->r_len - (bytes-28) - datalen;
memcpy(client->recv_buffer+complex, buffer+28+datalen, (bytes-28) - datalen);
complex = client->r_len - (bytes - 28) - datalen;
memcpy(client->recv_buffer + complex, buffer + 28 + datalen, (bytes - 28) - datalen);
free(buffer);
client->header->ocnt += bytes-28;
client->header->ocnt += bytes - 28;
*recv_bytes = datalen;
return IPHONE_E_SUCCESS;
} else {
// Fill the data with what we have, and just return.
memcpy(data+offset, buffer+28, bytes-28); // data+offset: see #2b, above
client->header->ocnt += bytes-28;
memcpy(data + offset, buffer + 28, bytes - 28); // data+offset: see #2b, above
client->header->ocnt += bytes - 28;
free(buffer);
*recv_bytes = bytes - 28;
return IPHONE_E_SUCCESS;
}
// If we get to this point, 'tis probably bad.
if (debug) printf("mux_recv: Heisenbug: bytes and datalen not matching up\n");
if (debug)
printf("mux_recv: Heisenbug: bytes and datalen not matching up\n");
return IPHONE_E_UNKNOWN_ERROR;
}
......@@ -39,10 +39,11 @@ extern int debug;
/** Creates a freedesktop compatible configuration directory for libiphone.
*/
inline void create_config_dir() {
gchar* config_dir = g_build_path(G_DIR_SEPARATOR_S, g_get_user_config_dir(), LIBIPHONE_CONF_DIR, NULL);
inline void create_config_dir()
{
gchar *config_dir = g_build_path(G_DIR_SEPARATOR_S, g_get_user_config_dir(), LIBIPHONE_CONF_DIR, NULL);
if (!g_file_test(config_dir, (G_FILE_TEST_EXISTS | G_FILE_TEST_IS_DIR) ))
if (!g_file_test(config_dir, (G_FILE_TEST_EXISTS | G_FILE_TEST_IS_DIR)))
g_mkdir_with_parents(config_dir, 0755);
g_free(config_dir);
......@@ -55,26 +56,29 @@ inline void create_config_dir() {
*
* @return The string containing the HostID or NULL
*/
char* get_host_id() {
char* host_id = NULL;
gchar* config_file;
GKeyFile* key_file;
gchar* loc_host_id;
char *get_host_id()
{
char *host_id = NULL;
gchar *config_file;
GKeyFile *key_file;
gchar *loc_host_id;
config_file = g_build_path(G_DIR_SEPARATOR_S, g_get_user_config_dir(), LIBIPHONE_CONF_DIR, LIBIPHONE_CONF_FILE, NULL);
config_file =
g_build_path(G_DIR_SEPARATOR_S, g_get_user_config_dir(), LIBIPHONE_CONF_DIR, LIBIPHONE_CONF_FILE, NULL);
/* now parse file to get the HostID */
key_file = g_key_file_new();
if(g_key_file_load_from_file(key_file, config_file, G_KEY_FILE_KEEP_COMMENTS, NULL)) {
if (g_key_file_load_from_file(key_file, config_file, G_KEY_FILE_KEEP_COMMENTS, NULL)) {
loc_host_id = g_key_file_get_value(key_file, "Global", "HostID", NULL);
if (loc_host_id)
host_id = strdup((char*)loc_host_id);
host_id = strdup((char *) loc_host_id);
g_free(loc_host_id);
}
g_key_file_free(key_file);
g_free(config_file);
if (debug) printf("get_host_id(): Using %s as HostID\n",host_id);
if (debug)
printf("get_host_id(): Using %s as HostID\n", host_id);
return host_id;
}
......@@ -85,7 +89,8 @@ char* get_host_id() {
* @return 1 if the iPhone has been connected previously to this configuration
* or 0 otherwise.
*/
int is_device_known(char* uid) {
int is_device_known(char *uid)
{
int ret = 0;
gchar *config_file;
GKeyFile *key_file;
......@@ -93,7 +98,7 @@ int is_device_known(char* uid) {
GIOChannel *keyfile;
/* first get config file */
gchar* device_file = g_strconcat(uid, ".pem", NULL);
gchar *device_file = g_strconcat(uid, ".pem", NULL);
config_file = g_build_path(G_DIR_SEPARATOR_S, g_get_user_config_dir(), LIBIPHONE_CONF_DIR, device_file, NULL);
if (g_file_test(config_file, (G_FILE_TEST_EXISTS | G_FILE_TEST_IS_REGULAR)))
ret = 1;
......@@ -110,7 +115,8 @@ int is_device_known(char* uid) {
* @return 1 on success and 0 if no public key is given or if it has already
* been marked as connected previously.
*/
int store_device_public_key(char* uid, char* public_key) {
int store_device_public_key(char *uid, char *public_key)
{
if (NULL == public_key || is_device_known(uid))
return 0;
......@@ -119,14 +125,14 @@ int store_device_public_key(char* uid, char* public_key) {
create_config_dir();
/* build file path */
gchar* device_file = g_strconcat(uid, ".pem", NULL);
gchar* pem = g_build_path(G_DIR_SEPARATOR_S, g_get_user_config_dir(), LIBIPHONE_CONF_DIR, device_file, NULL);
gchar *device_file = g_strconcat(uid, ".pem", NULL);
gchar *pem = g_build_path(G_DIR_SEPARATOR_S, g_get_user_config_dir(), LIBIPHONE_CONF_DIR, device_file, NULL);
/* decode public key for storing */
gsize decoded_size;
gchar* data = g_base64_decode (public_key, &decoded_size);
gchar *data = g_base64_decode(public_key, &decoded_size);
/* store file */
FILE* pFile = fopen(pem , "wb");
FILE *pFile = fopen(pem, "wb");
fwrite(data, 1, decoded_size, pFile);
fclose(pFile);
g_free(pem);
......@@ -142,7 +148,8 @@ int store_device_public_key(char* uid, char* public_key) {
*
* @return 1 if the file contents where read successfully and 0 otherwise.
*/
int read_file_in_confdir(char* file, gnutls_datum_t* data) {
int read_file_in_confdir(char *file, gnutls_datum_t * data)
{
gboolean success;
gsize size;
char *content;
......@@ -169,7 +176,8 @@ int read_file_in_confdir(char* file, gnutls_datum_t* data) {
*
* @return 1 if the file was successfully read and 0 otherwise.
*/
int get_root_private_key(gnutls_datum_t* root_privkey) {
int get_root_private_key(gnutls_datum_t * root_privkey)
{
return read_file_in_confdir(LIBIPHONE_ROOT_PRIVKEY, root_privkey);
}
......@@ -179,7 +187,8 @@ int get_root_private_key(gnutls_datum_t* root_privkey) {
*
* @return 1 if the file was successfully read and 0 otherwise.
*/
int get_host_private_key(gnutls_datum_t* host_privkey) {
int get_host_private_key(gnutls_datum_t * host_privkey)
{
return read_file_in_confdir(LIBIPHONE_HOST_PRIVKEY, host_privkey);
}
......@@ -189,7 +198,8 @@ int get_host_private_key(gnutls_datum_t* host_privkey) {
*
* @return 1 if the file was successfully read and 0 otherwise.
*/
int get_root_certificate(gnutls_datum_t* root_cert) {
int get_root_certificate(gnutls_datum_t * root_cert)
{
return read_file_in_confdir(LIBIPHONE_ROOT_CERTIF, root_cert);
}
......@@ -199,7 +209,8 @@ int get_root_certificate(gnutls_datum_t* root_cert) {
*
* @return 1 if the file was successfully read and 0 otherwise.
*/
int get_host_certificate(gnutls_datum_t* host_cert) {
int get_host_certificate(gnutls_datum_t * host_cert)
{
return read_file_in_confdir(LIBIPHONE_HOST_CERTIF, host_cert);
}
......@@ -215,30 +226,34 @@ int get_host_certificate(gnutls_datum_t* host_cert) {
*
* @return 1 on success and 0 otherwise.
*/
int init_config_file(char* host_id, gnutls_datum_t* root_key, gnutls_datum_t* host_key, gnutls_datum_t* root_cert, gnutls_datum_t* host_cert) {
FILE * pFile;
gchar* pem;
GKeyFile* key_file;
int init_config_file(char *host_id, gnutls_datum_t * root_key, gnutls_datum_t * host_key, gnutls_datum_t * root_cert,
gnutls_datum_t * host_cert)
{
FILE *pFile;
gchar *pem;
GKeyFile *key_file;
gsize length;
gchar *buf, *config_file;
GIOChannel* file;
GIOChannel *file;
if (!host_id || !root_key || !host_key || !root_cert || !host_cert)
return 0;
/* Make sure config directory exists*/
/* Make sure config directory exists */
create_config_dir();
/* Now parse file to get the HostID */
key_file = g_key_file_new();
/* Store in config file */
if (debug) printf("init_config_file(): setting hostID to %s\n", host_id);
if (debug)
printf("init_config_file(): setting hostID to %s\n", host_id);
g_key_file_set_value(key_file, "Global", "HostID", host_id);
/* Write config file on disk */
buf = g_key_file_to_data(key_file, &length,NULL);
config_file = g_build_path(G_DIR_SEPARATOR_S, g_get_user_config_dir(), LIBIPHONE_CONF_DIR, LIBIPHONE_CONF_FILE, NULL);
buf = g_key_file_to_data(key_file, &length, NULL);
config_file =
g_build_path(G_DIR_SEPARATOR_S, g_get_user_config_dir(), LIBIPHONE_CONF_DIR, LIBIPHONE_CONF_FILE, NULL);
file = g_io_channel_new_file(config_file, "w", NULL);
g_free(config_file);
g_io_channel_write_chars(file, buf, length, NULL, NULL);
......@@ -249,26 +264,26 @@ int init_config_file(char* host_id, gnutls_datum_t* root_key, gnutls_datum_t* ho
/* Now write keys and certificates to disk */
pem = g_build_path(G_DIR_SEPARATOR_S, g_get_user_config_dir(), LIBIPHONE_CONF_DIR, LIBIPHONE_ROOT_PRIVKEY, NULL);
pFile = fopen(pem , "wb");
fwrite(root_key->data, 1 , root_key->size , pFile );
pFile = fopen(pem, "wb");
fwrite(root_key->data, 1, root_key->size, pFile);
fclose(pFile);
g_free(pem);
pem = g_build_path(G_DIR_SEPARATOR_S, g_get_user_config_dir(), LIBIPHONE_CONF_DIR, LIBIPHONE_HOST_PRIVKEY, NULL);
pFile = fopen(pem , "wb");
fwrite(host_key->data, 1 , host_key->size , pFile);
pFile = fopen(pem, "wb");
fwrite(host_key->data, 1, host_key->size, pFile);
fclose(pFile);
g_free(pem);
pem = g_build_path(G_DIR_SEPARATOR_S, g_get_user_config_dir(), LIBIPHONE_CONF_DIR, LIBIPHONE_ROOT_CERTIF, NULL);
pFile = fopen(pem , "wb");
fwrite(root_cert->data, 1 , root_cert->size , pFile);
pFile = fopen(pem, "wb");
fwrite(root_cert->data, 1, root_cert->size, pFile);
fclose(pFile);
g_free(pem);
pem = g_build_path(G_DIR_SEPARATOR_S, g_get_user_config_dir(), LIBIPHONE_CONF_DIR, LIBIPHONE_HOST_CERTIF, NULL);
pFile = fopen(pem , "wb");
fwrite(host_cert->data, 1 , host_cert->size , pFile);
pFile = fopen(pem, "wb");
fwrite(host_cert->data, 1, host_cert->size, pFile);
fclose(pFile);
g_free(pem);
......
......@@ -28,44 +28,44 @@
*
* @return the HostID if exist in config file. Returns NULL otherwise.
*/
char* get_host_id();
char *get_host_id();
/**
* Determine if we already paired this device.
*
* @return 1 if device is already paired. Returns 0 otherwise.
*/
int is_device_known(char* uid);
int is_device_known(char *uid);
/**
* @return 1 if everything went well. Returns 0 otherwise.
*/
int store_device_public_key(char* uid, char* public_key);
int store_device_public_key(char *uid, char *public_key);
/**
* @return 1 if everything went well. Returns 0 otherwise.
*/
int get_root_private_key(gnutls_datum_t* root_privkey);
int get_root_private_key(gnutls_datum_t * root_privkey);
/**
* @return 1 if everything went well. Returns 0 otherwise.
*/
int get_host_private_key(gnutls_datum_t* host_privkey);
int get_host_private_key(gnutls_datum_t * host_privkey);
/**
* @return 1 if everything went well. Returns 0 otherwise.
*/
int get_root_certificate(gnutls_datum_t* root_cert);
int get_root_certificate(gnutls_datum_t * root_cert);
/**
* @return 1 if everything went well. Returns 0 otherwise.
*/
int get_host_certificate(gnutls_datum_t* host_cert);
int get_host_certificate(gnutls_datum_t * host_cert);
/**
* Setup a brand new config file.
* @return 1 if everything went well. Returns 0 otherwise.
*/
int init_config_file(char* host_id, gnutls_datum_t* root_key, gnutls_datum_t* host_key, gnutls_datum_t* root_cert, gnutls_datum_t* host_cert);
int init_config_file(char *host_id, gnutls_datum_t * root_key, gnutls_datum_t * host_key, gnutls_datum_t * root_cert,
gnutls_datum_t * host_cert);
#endif
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment