static uint16_t
ptp_ptpip_event (PTPParams* params, PTPContainer* event, int wait)
{
fd_set infds;
struct timeval timeout;
int ret;
unsigned char* data = NULL;
PTPIPHeader hdr;
int n;
while (1) {
FD_ZERO(&infds);
FD_SET(params->evtfd, &infds);
timeout.tv_sec = 0;
if (wait == PTP_EVENT_CHECK_FAST)
timeout.tv_usec = 1;
else
timeout.tv_usec = 1000; /* 1/1000 second .. perhaps wait longer? */
ret = select (params->evtfd+1, &infds, NULL, NULL, &timeout);
if (1 != ret) {
if (-1 == ret) {
gp_log (GP_LOG_DEBUG,"ptpip/event", "select returned error, errno is %d", errno);
return PTP_ERROR_IO;
}
return PTP_ERROR_TIMEOUT;
}
ret = ptp_ptpip_evt_read (params, &hdr, &data);
if (ret != PTP_RC_OK)
return ret;
gp_log (GP_LOG_DEBUG,"ptpip/event", "hdr type %d, length %d", hdr.type, hdr.length);
if (dtoh32(hdr.type) == PTPIP_EVENT) {
break;
}
/* TODO: Handle cancel transaction and ping/pong
* If not PTPIP_EVENT, process it and wait for next PTPIP_EVENT
*/
gp_log (GP_LOG_ERROR, "ptpip/event", "unknown/unhandled event type %d", dtoh32(hdr.type));
}
event->Code = dtoh16a(&data[ptpip_event_code]);
event->Transaction_ID = dtoh32a(&data[ptpip_event_transid]);
n = (dtoh32(hdr.length) - sizeof(hdr) - ptpip_event_param1)/sizeof(uint32_t);
switch (n) {
case 3: event->Param3 = dtoh32a(&data[ptpip_event_param3]);
case 2: event->Param2 = dtoh32a(&data[ptpip_event_param2]);
case 1: event->Param1 = dtoh32a(&data[ptpip_event_param1]);
case 0: break;
default:
gp_log( GP_LOG_ERROR, "ptpip/event", "response got %d parameters?", n);
break;
}
free (data);
return PTP_RC_OK;
}
static uint16_t
ptp_ptpip_init_command_ack (PTPParams* params)
{
PTPIPHeader hdr;
unsigned char *data = NULL;
uint16_t ret;
int i;
unsigned short *name;
ret = ptp_ptpip_generic_read (params, params->cmdfd, &hdr, &data);
if (ret != PTP_RC_OK)
return ret;
if (hdr.type != dtoh32(PTPIP_INIT_COMMAND_ACK)) {
gp_log (GP_LOG_ERROR, "ptpip/init_cmd_ack", "bad type returned %d", htod32(hdr.type));
free (data);
return PTP_RC_GeneralError;
}
params->eventpipeid = dtoh32a(&data[ptpip_cmdack_idx]);
memcpy (params->cameraguid, &data[ptpip_cmdack_guid], 16);
name = (unsigned short*)&data[ptpip_cmdack_name];
for (i=0;name[i];i++) /* EMPTY */;
params->cameraname = malloc((i+1)*sizeof(uint16_t));
for (i=0;name[i];i++)
params->cameraname[i] = name[i];
free (data);
return PTP_RC_OK;
}
uint16_t
ptp_ptpip_getresp (PTPParams* params, PTPContainer* resp)
{
PTPIPHeader hdr;
unsigned char *data = NULL;
uint16_t ret;
int n;
ret = ptp_ptpip_cmd_read (params, &hdr, &data);
if (ret != PTP_RC_OK)
return ret;
resp->Code = dtoh16a(&data[ptpip_resp_code]);
resp->Transaction_ID = dtoh32a(&data[ptpip_resp_transid]);
n = (dtoh32(hdr.length) - sizeof(hdr) - ptpip_resp_param1)/sizeof(uint32_t);
switch (n) {
case 5: resp->Param5 = dtoh32a(&data[ptpip_resp_param5]);
case 4: resp->Param4 = dtoh32a(&data[ptpip_resp_param4]);
case 3: resp->Param3 = dtoh32a(&data[ptpip_resp_param3]);
case 2: resp->Param2 = dtoh32a(&data[ptpip_resp_param2]);
case 1: resp->Param1 = dtoh32a(&data[ptpip_resp_param1]);
case 0: break;
default:
gp_log( GP_LOG_ERROR, "ptpip/getresp", "response got %d parameters?", n);
break;
}
free (data);
return PTP_RC_OK;
}
static uint16_t
ptp_ptpip_init_command_ack(PTPParams *params)
{
PTPIPHeader hdr;
unsigned char *data = NULL;
uint16_t ret;
ret = ptp_ptpip_generic_read(params, params->cmdfd, &hdr, &data);
if (ret != PTP_RC_OK)
return ret;
if (hdr.type != dtoh32(PTPIP_INIT_COMMAND_ACK))
{
VitaMTP_Log(VitaMTP_ERROR, "ptpip/init_cmd_ack: bad type returned %d\n", htod32(hdr.type));
return PTP_RC_GeneralError;
}
params->eventpipeid = dtoh32a(&data[ptpip_cmdack_idx]);
free(data);
return PTP_RC_OK;
}
static inline uint16_t
ptp_ptpip_event(PTPParams *params, PTPContainer *event, int wait)
{
fd_set infds;
struct timeval timeout;
int ret;
unsigned char *data = NULL;
PTPIPHeader hdr;
int n;
while (1)
{
if (wait == PTP_EVENT_CHECK_FAST)
{
FD_ZERO(&infds);
FD_SET(params->evtfd, &infds);
timeout.tv_sec = 0;
timeout.tv_usec = 1;
if (1 != select(params->evtfd+1, &infds, NULL, NULL, &timeout))
return PTP_RC_OK;
}
ret = ptp_ptpip_evt_read(params, &hdr, &data);
if (ret != PTP_RC_OK)
return ret;
VitaMTP_Log(VitaMTP_DEBUG,"ptpip/event: hdr type %d, length %d\n", hdr.type, hdr.length);
if (dtoh32(hdr.type) == PTPIP_EVENT)
{
break;
}
// TODO: Handle cancel transaction and ping/pong
VitaMTP_Log(VitaMTP_ERROR, "ptpip/event: unknown/unhandled event type %d\n", hdr.type);
}
event->Code = dtoh16a(&data[ptpip_event_code]);
event->Transaction_ID = dtoh32a(&data[ptpip_event_transid]);
n = (dtoh32(hdr.length) - sizeof(hdr) - ptpip_event_param1)/sizeof(uint32_t);
switch (n)
{
case 3:
event->Param3 = dtoh32a(&data[ptpip_event_param3]);
case 2:
event->Param2 = dtoh32a(&data[ptpip_event_param2]);
case 1:
event->Param1 = dtoh32a(&data[ptpip_event_param1]);
case 0:
break;
default:
VitaMTP_Log(VitaMTP_ERROR, "ptpip/event: response got %d parameters?\n", n);
break;
}
free(data);
return PTP_RC_OK;
}
uint16_t
ptp_ptpip_getdata(PTPParams *params, PTPContainer *ptp, PTPDataHandler *handler)
{
PTPIPHeader hdr;
unsigned char *xdata = NULL;
uint16_t ret;
unsigned long toread, curread;
int xret;
ret = ptp_ptpip_cmd_read(params, &hdr, &xdata);
if (ret != PTP_RC_OK)
return ret;
if (dtoh32(hdr.type) == PTPIP_CMD_RESPONSE) /* might happen if we have no data transfer due to error? */
{
VitaMTP_Log(VitaMTP_ERROR, "ptpip/getdata: Unexpected ptp response, code %x\n", dtoh32a(&xdata[8]));
return PTP_RC_GeneralError;
}
if (dtoh32(hdr.type) != PTPIP_START_DATA_PACKET)
{
VitaMTP_Log(VitaMTP_ERROR, "ptpip/getdata: got reply type %d\n", dtoh32(hdr.type));
return PTP_RC_GeneralError;
}
toread = dtoh32a(&xdata[ptpip_data_payload]);
free(xdata);
xdata = NULL;
curread = 0;
while (curread < toread)
{
ret = ptp_ptpip_cmd_read(params, &hdr, &xdata);
if (ret != PTP_RC_OK)
return ret;
if (dtoh32(hdr.type) == PTPIP_END_DATA_PACKET)
{
unsigned long written;
unsigned long datalen = dtoh32(hdr.length)-8-ptpip_data_payload;
if (datalen > (toread-curread))
{
VitaMTP_Log(VitaMTP_ERROR, "ptpip/getdata: returned data is too much, expected %ld, got %ld\n",
(toread-curread),datalen
);
break;
}
xret = handler->putfunc(params, handler->priv,
datalen, xdata+ptpip_data_payload, &written
);
if (xret == -1)
{
VitaMTP_Log(VitaMTP_ERROR, "ptpip/getdata: failed to putfunc of returned data\n");
break;
}
curread += written;
free(xdata);
xdata = NULL;
continue;
}
if (dtoh32(hdr.type) == PTPIP_DATA_PACKET)
{
unsigned long written;
unsigned long datalen = dtoh32(hdr.length)-8-ptpip_data_payload;
if (datalen > (toread-curread))
{
VitaMTP_Log(VitaMTP_ERROR, "ptpip/getdata: returned data is too much, expected %ld, got %ld\n",
(toread-curread),datalen
);
break;
}
xret = handler->putfunc(params, handler->priv,
datalen, xdata+ptpip_data_payload, &written
);
if (xret == -1)
{
VitaMTP_Log(VitaMTP_ERROR, "ptpip/getdata: failed to putfunc of returned data\n");
break;
}
curread += written;
free(xdata);
xdata = NULL;
continue;
}
VitaMTP_Log(VitaMTP_ERROR, "ptpip/getdata: ret type %d\n", hdr.type);
}
if (curread < toread)
return PTP_RC_GeneralError;
return PTP_RC_OK;
}
