static uint16_t
ptp_ptpip_init_event_request(PTPParams *params)
{
unsigned char evtrequest[ptpip_eventinit_size];
ssize_t ret;
htod32a(&evtrequest[ptpip_type],PTPIP_INIT_EVENT_REQUEST);
htod32a(&evtrequest[ptpip_len],ptpip_eventinit_size);
htod32a(&evtrequest[ptpip_eventinit_idx],params->eventpipeid);
VitaMTP_Log(VitaMTP_DEBUG, "ptpip/init_event recieved\n");
if (MASK_SET(g_VitaMTP_logmask, VitaMTP_DEBUG))
{
VitaMTP_hex_dump(evtrequest, ptpip_eventinit_size, 16);
}
ret = write(params->evtfd, evtrequest, ptpip_eventinit_size);
if (ret == -1)
{
perror("write init evt request");
return PTP_RC_GeneralError;
}
if (ret != ptpip_eventinit_size)
{
VitaMTP_Log(VitaMTP_ERROR, "ptpip: unexpected retsize %zd, expected %d\n", ret, ptpip_eventinit_size);
return PTP_RC_GeneralError;
}
return PTP_RC_OK;
}
/* send / receive functions */
uint16_t
ptp_ptpip_sendreq(PTPParams *params, PTPContainer *req)
{
ssize_t ret;
uint32_t len = 18+req->Nparam*4;
unsigned char *request = malloc(len);
//ptp_ptpip_check_event (params);
htod32a(&request[ptpip_type],PTPIP_CMD_REQUEST);
htod32a(&request[ptpip_len],len);
htod32a(&request[ptpip_cmd_dataphase],1); /* FIXME: dataphase handling */
htod16a(&request[ptpip_cmd_code],req->Code);
htod32a(&request[ptpip_cmd_transid],req->Transaction_ID);
switch (req->Nparam)
{
case 5:
htod32a(&request[ptpip_cmd_param5],req->Param5);
case 4:
htod32a(&request[ptpip_cmd_param4],req->Param4);
case 3:
htod32a(&request[ptpip_cmd_param3],req->Param3);
case 2:
htod32a(&request[ptpip_cmd_param2],req->Param2);
case 1:
htod32a(&request[ptpip_cmd_param1],req->Param1);
case 0:
default:
break;
}
VitaMTP_Log(VitaMTP_DEBUG, "ptpip/oprequest\n");
if (MASK_SET(g_VitaMTP_logmask, VitaMTP_DEBUG))
{
VitaMTP_hex_dump(request, len, 16);
}
ret = write(params->cmdfd, request, len);
free(request);
if (ret == -1)
perror("sendreq/write to cmdfd");
if (ret != len)
{
VitaMTP_Log(VitaMTP_ERROR, "ptpip: ptp_ptpip_sendreq() len =%d but ret=%zd\n", len, ret);
return PTP_RC_OK;
}
return PTP_RC_OK;
}
static uint16_t
ptp_ptpip_init_command_request(PTPParams *params)
{
unsigned char *cmdrequest;
unsigned int len;
ssize_t ret;
unsigned char guid[16] = {0};
// TODO: See if GUID is required
len = ptpip_initcmd_name;
cmdrequest = malloc(len);
htod32a(&cmdrequest[ptpip_type],PTPIP_INIT_COMMAND_REQUEST);
htod32a(&cmdrequest[ptpip_len],len);
memcpy(&cmdrequest[ptpip_initcmd_guid], guid, 16);
VitaMTP_Log(VitaMTP_DEBUG, "ptpip/init_cmd recieved\n");
if (MASK_SET(g_VitaMTP_logmask, VitaMTP_DEBUG))
{
VitaMTP_hex_dump(cmdrequest, len, 16);
}
ret = write(params->cmdfd, cmdrequest, len);
free(cmdrequest);
if (ret == -1)
{
perror("write init cmd request");
return PTP_RC_GeneralError;
}
VitaMTP_Log(VitaMTP_ERROR, "ptpip/init_cmd: return %zd / len %d\n", ret, len);
if (ret != len)
{
VitaMTP_Log(VitaMTP_ERROR, "ptpip: return %zd vs len %d\n", ret, len);
return PTP_RC_GeneralError;
}
return PTP_RC_OK;
}
static uint16_t
ptp_ptpip_init_command_request (PTPParams* params)
{
char hostname[100];
unsigned char* cmdrequest;
unsigned int i;
int len, ret;
unsigned char guid[16];
ptp_nikon_getptpipguid(guid);
if (gethostname (hostname, sizeof(hostname)))
return PTP_RC_GeneralError;
len = ptpip_initcmd_name + (strlen(hostname)+1)*2 + 4;
cmdrequest = malloc(len);
htod32a(&cmdrequest[ptpip_type],PTPIP_INIT_COMMAND_REQUEST);
htod32a(&cmdrequest[ptpip_len],len);
memcpy(&cmdrequest[ptpip_initcmd_guid], guid, 16);
for (i=0;i<strlen(hostname)+1;i++) {
/* -> ucs-2 in little endian */
cmdrequest[ptpip_initcmd_name+i*2] = hostname[i];
cmdrequest[ptpip_initcmd_name+i*2+1] = 0;
}
htod16a(&cmdrequest[ptpip_initcmd_name+(strlen(hostname)+1)*2],PTPIP_VERSION_MINOR);
htod16a(&cmdrequest[ptpip_initcmd_name+(strlen(hostname)+1)*2+2],PTPIP_VERSION_MAJOR);
gp_log_data ( "ptpip/init_cmd", (char*)cmdrequest, len);
ret = write (params->cmdfd, cmdrequest, len);
free (cmdrequest);
if (ret == -1) {
perror("write init cmd request");
return PTP_RC_GeneralError;
}
gp_log (GP_LOG_ERROR,"ptpip/init_cmd", "return %d / len %d", ret, len);
if (ret != len) {
gp_log (GP_LOG_ERROR, "ptpip", "return %d vs len %d", ret, len);
return PTP_RC_GeneralError;
}
return PTP_RC_OK;
}
uint16_t
ptp_usb_control_cancel_request (PTPParams *params, uint32_t transactionid) {
Camera *camera = ((PTPData *)params->data)->camera;
int ret;
unsigned char buffer[6];
htod16a(&buffer[0],PTP_EC_CancelTransaction);
htod32a(&buffer[2],transactionid);
ret = gp_port_usb_msg_class_write (camera->port, 0x64, 0x0000, 0x0000, (char*)buffer, sizeof (buffer));
if (ret < GP_OK)
return PTP_ERROR_IO;
return PTP_RC_OK;
}
static uint16_t
ptp_ptpip_init_event_request (PTPParams* params)
{
unsigned char evtrequest[ptpip_eventinit_size];
int ret;
htod32a(&evtrequest[ptpip_type],PTPIP_INIT_EVENT_REQUEST);
htod32a(&evtrequest[ptpip_len],ptpip_eventinit_size);
htod32a(&evtrequest[ptpip_eventinit_idx],params->eventpipeid);
gp_log_data ( "ptpip/init_event", (char*)evtrequest, ptpip_eventinit_size);
ret = write (params->evtfd, evtrequest, ptpip_eventinit_size);
if (ret == -1) {
perror("write init evt request");
return PTP_RC_GeneralError;
}
if (ret != ptpip_eventinit_size) {
gp_log (GP_LOG_ERROR, "ptpip", "unexpected retsize %d, expected %d", ret, ptpip_eventinit_size);
return PTP_RC_GeneralError;
}
return PTP_RC_OK;
}
/* send / receive functions */
uint16_t
ptp_ptpip_sendreq (PTPParams* params, PTPContainer* req)
{
int ret;
int len = 18+req->Nparam*4;
unsigned char *request = malloc(len);
ptp_ptpip_check_event (params);
htod32a(&request[ptpip_type],PTPIP_CMD_REQUEST);
htod32a(&request[ptpip_len],len);
htod32a(&request[ptpip_cmd_dataphase],1); /* FIXME: dataphase handling */
htod16a(&request[ptpip_cmd_code],req->Code);
htod32a(&request[ptpip_cmd_transid],req->Transaction_ID);
switch (req->Nparam) {
case 5: htod32a(&request[ptpip_cmd_param5],req->Param5);
case 4: htod32a(&request[ptpip_cmd_param4],req->Param4);
case 3: htod32a(&request[ptpip_cmd_param3],req->Param3);
case 2: htod32a(&request[ptpip_cmd_param2],req->Param2);
case 1: htod32a(&request[ptpip_cmd_param1],req->Param1);
case 0:
default:
break;
}
gp_log_data ( "ptpip/oprequest", (char*)request, len);
ret = write (params->cmdfd, request, len);
free (request);
if (ret == -1)
perror ("sendreq/write to cmdfd");
if (ret != len) {
gp_log (GP_LOG_ERROR, "ptpip","ptp_ptpip_sendreq() len =%d but ret=%d", len, ret);
return PTP_RC_OK;
}
return PTP_RC_OK;
}
uint16_t
ptp_ptpip_senddata(PTPParams *params, PTPContainer *ptp,
unsigned long size, PTPDataHandler *handler
)
{
unsigned char request[0x14];
ssize_t ret;
unsigned long curwrite, towrite;
unsigned char *xdata;
htod32a(&request[ptpip_type],PTPIP_START_DATA_PACKET);
htod32a(&request[ptpip_len],sizeof(request));
htod32a(&request[ptpip_startdata_transid + 8],ptp->Transaction_ID);
htod32a(&request[ptpip_startdata_totallen + 8],(uint32_t)size);
htod32a(&request[ptpip_startdata_unknown + 8],0);
VitaMTP_Log(VitaMTP_DEBUG, "ptpip/senddata\n");
if (MASK_SET(g_VitaMTP_logmask, VitaMTP_DEBUG))
{
VitaMTP_hex_dump(request, sizeof(request), 16);
}
ret = write(params->cmdfd, request, sizeof(request));
if (ret == -1)
perror("sendreq/write to cmdfd");
if (ret != sizeof(request))
{
VitaMTP_Log(VitaMTP_ERROR, "ptpip/senddata: ptp_ptpip_senddata() len=%d but ret=%zd\n", (int)sizeof(request), ret);
return PTP_RC_GeneralError;
}
xdata = malloc(WRITE_BLOCKSIZE+8+4);
if (!xdata) return PTP_RC_GeneralError;
curwrite = 0;
while (curwrite < size)
{
unsigned long type, written, towrite2, xtowrite;
//ptp_ptpip_check_event (params);
towrite = size - curwrite;
if (towrite > WRITE_BLOCKSIZE)
{
towrite = WRITE_BLOCKSIZE;
type = PTPIP_DATA_PACKET;
}
else
{
type = PTPIP_END_DATA_PACKET;
}
ret = handler->getfunc(params, handler->priv, towrite, &xdata[ptpip_data_payload+8], &xtowrite);
if (ret == -1)
{
perror("getfunc in senddata failed");
free(xdata);
return PTP_RC_GeneralError;
}
towrite2 = xtowrite + 12;
htod32a(&xdata[ptpip_type], (uint32_t)type);
htod32a(&xdata[ptpip_len], (uint32_t)towrite2);
htod32a(&xdata[ptpip_data_transid+8], ptp->Transaction_ID);
VitaMTP_Log(VitaMTP_DEBUG, "ptpip/senddata\n");
if (MASK_SET(g_VitaMTP_logmask, VitaMTP_DEBUG))
{
VitaMTP_hex_dump(xdata, (unsigned int)towrite2, 16);
}
written = 0;
while (written < towrite2)
{
ret = write(params->cmdfd, xdata+written, towrite2-written);
if (ret == -1)
{
perror("write in senddata failed");
free(xdata);
return PTP_RC_GeneralError;
}
written += ret;
}
curwrite += towrite;
}
free(xdata);
return PTP_RC_OK;
}
