void cec_worker_init(void)
{
cec_set_own_address(/*DEVICE_TYPE_UNREG*/ 0x0F);
dprintk(1, "*** CEC INIT ***\n");
str_status(cec_get_status());
str_error(cec_get_error());
dprintk(1, "~~~ CEC INIT ~~~\n");
sendPingWithAutoIncrement();
}
static void check_status(DavDeleteXMLParser::DavxDeleteXmlIntern & par, const std::string & name){
DAVIX_SLOG(DAVIX_LOG_DEBUG, DAVIX_LOG_XML, " status found -> parse it");
std::string str_status(name);
ltrim(str_status, StrUtil::isSpace());
std::string::iterator it1, it2;
it1 = std::find(str_status.begin(), str_status.end(), ' ');
if( it1 != str_status.end()){
it2 = std::find(it1+1, str_status.end(), ' ');
std::string str_status_parsed(it1+1, it2);
unsigned long res = strtoul(str_status_parsed.c_str(), NULL, 10);
if(res != ULONG_MAX){
DAVIX_SLOG(DAVIX_LOG_DEBUG, DAVIX_LOG_XML, " status value : {}", res);
par._last_response_status = res;
return;
}
}
DAVIX_SLOG(DAVIX_LOG_VERBOSE, DAVIX_LOG_XML, "Invalid dav status field value");
errno =0;
}
char *get_status(char *line, struct response *resp)
{
enum status stat;
char *t;
int len;
char *c =
get_token(line, &t, &len, false, REQUIRES_EITHER, "Invalid status");
if (c == NULL)
return c;
for (stat = STATUS_OK; stat <= STATUS_ERROR; stat++) {
const char *cmp_status = str_status(stat);
if (strlen(cmp_status) != len)
continue;
if (strncasecmp(cmp_status, t, len) == 0) {
enum requires_more requires_more = REQUIRES_MORE;
resp->r_status = stat;
if (stat == STATUS_COMPLETED
|| (resp->r_cmd == CMD_QUIT && stat == STATUS_OK))
requires_more = REQUIRES_NO_MORE;
return SkipWhite(c, requires_more, "get_status");
}
}
strcpy(errdetail, "Invalid status");
strncpy(badtoken, t, len);
badtoken[len] = '\0';
errno = EINVAL;
return NULL;
}
irqreturn_t cec_interrupt(int irq, void *dev_id)
{
u8 status, error;
dprintk(4, "#### CEC INTERUPT START####\n");
status = cec_get_status();
error = cec_get_error();
if (status & CEC_STATUS_RECV_ERR) // Error while receiving
{
dprintk(3,"++++ CEC ERROR (RECV) ++++\n");
str_error(error);
str_status(status);
cec_acknowledge();
}
else if (status & CEC_STATUS_SEND_ERR) // Error while sending
{
dprintk(3,"++++ CEC ERROR (SEND) ++++\n");
str_error(error);
str_status(status);
if (status & CEC_STATUS_SEND_EOMSG) // End of Message
cec_acknowledge_eom();
else
cec_acknowledge();
isSending = 0;
dprintk(4,"Retries: %d\n", retries);
if (getIsFirstKiss() == 1) {
if (error & CEC_ERROR_ACK)
{
dprintk(0, "The above error is a wanted behaviour as this was a ping!\n");
setIsFirstKiss(0);
}
else if(retries > 0)
{
sendMessageWithRetry(sizeOfSendBuf, sendBuf, retries - 1);
}
}
else if(retries > 0)
{
sendMessageWithRetry(sizeOfSendBuf, sendBuf, retries - 1);
}
}
else if (status & CEC_STATUS_RECV_BTF) // Receiving
{
if (status & CEC_STATUS_RECV_SOMSG) // Start of Message
{
isReceiving = 1;
indexOfRecvBuf = 0;
memset(recvBuf, 0, RECV_BUF_SIZE);
}
recvBuf[indexOfRecvBuf] = cec_read_data();
dprintk(3,"RECV 0x%0x\n", recvBuf[indexOfRecvBuf]);
cec_acknowledge();
indexOfRecvBuf++;
if (status & CEC_STATUS_RECV_EOMSG) // End of Message
{
isReceiving = 0;
parseRawMessage(indexOfRecvBuf, recvBuf, "RX");
}
}
else if (status & CEC_STATUS_SEND_BTF) // Transmitting
{
if (status & CEC_STATUS_SEND_EOMSG) // End of Message
{
isSending = 0;
cec_acknowledge();
parseRawMessage(indexOfSendBuf, sendBuf, "TX");
}
else
{
cec_write_data(sendBuf[indexOfSendBuf]);
indexOfSendBuf++;
if(indexOfSendBuf == sizeOfSendBuf)
{
cec_acknowledge_eom();
}
else
{
cec_acknowledge();
}
}
}
dprintk(4, "#### CEC INTERUPT END####\n");
return IRQ_HANDLED;
}
char *parse_response(char *line, struct response *resp)
{
char *rest;
long long int dummy_len;
if (resp->r_original == '\0')
strcpy(resp->r_original, line);
resp->r_cmd = NUM_COMMANDS;
resp->r_tag = -1;
rest = get_tag(line, resp, true, REQUIRES_MORE);
if (rest == NULL)
goto fail;
rest = get_command(rest, &resp->r_cmd);
if (rest == NULL)
goto fail;
rest = get_status(rest, resp);
if (rest == NULL)
goto fail;
switch (resp->r_status) {
case STATUS_OK:
switch (resp->r_cmd) {
case CMD_COMMENT:
case CMD_HELLO:
rest =
get_str(rest, resp->r_data, &resp->r_length,
REQUIRES_NO_MORE);
break;
case CMD_LOCKW:
case CMD_LOCK:
case CMD_UNLOCK:
case CMD_TEST:
case CMD_LIST:
case CMD_HOP:
case CMD_UNHOP:
case NUM_COMMANDS:
strcpy(errdetail, "Unexpected Status");
errno = EINVAL;
sprintf(badtoken, "%s", str_status(resp->r_status));
goto fail;
case CMD_ALARM:
return get_long(rest, &resp->r_secs, REQUIRES_NO_MORE,
"Invalid alarm time");
case CMD_QUIT:
return rest;
case CMD_OPEN:
rest = get_fpos(rest, &resp->r_fpos, REQUIRES_MORE);
if (rest == NULL)
goto fail;
rest =
get_long(rest, &resp->r_fno, REQUIRES_NO_MORE,
"Invalid file number");
break;
case CMD_CLOSE:
case CMD_SEEK:
rest = get_fpos(rest, &resp->r_fpos, REQUIRES_NO_MORE);
break;
case CMD_WRITE:
rest = get_fpos(rest, &resp->r_fpos, REQUIRES_MORE);
if (rest == NULL)
goto fail;
rest =
get_longlong(rest, &resp->r_length,
REQUIRES_NO_MORE, "Invalid length");
break;
case CMD_READ:
rest = get_fpos(rest, &resp->r_fpos, REQUIRES_MORE);
if (rest == NULL)
goto fail;
rest =
get_longlong(rest, &resp->r_length, REQUIRES_MORE,
"Invalid length");
if (rest == NULL)
goto fail;
rest =
get_str(rest, resp->r_data, &dummy_len,
REQUIRES_NO_MORE);
if (dummy_len != resp->r_length) {
strcpy(errdetail, "Read length doesn't match");
errno = EINVAL;
sprintf(badtoken, "%lld != %lld", dummy_len,
resp->r_length);
goto fail;
}
break;
}
break;
case STATUS_AVAILABLE:
case STATUS_GRANTED:
case STATUS_DENIED:
case STATUS_DEADLOCK:
rest = get_fpos(rest, &resp->r_fpos, REQUIRES_MORE);
if (rest == NULL)
goto fail;
if (resp->r_cmd != CMD_LIST) {
rest = get_lock_type(rest, &resp->r_lock_type);
if (rest == NULL)
goto fail;
}
rest =
get_longlong(rest, &resp->r_start, REQUIRES_MORE,
"Invalid lock start");
if (rest == NULL)
goto fail;
rest =
get_longlong(rest, &resp->r_length, REQUIRES_NO_MORE,
"Invalid lock length");
break;
case STATUS_CONFLICT:
rest = get_fpos(rest, &resp->r_fpos, REQUIRES_MORE);
if (rest == NULL)
goto fail;
rest =
get_long(rest, &resp->r_pid, REQUIRES_MORE,
"Invalid conflict pid");
if (rest == NULL)
goto fail;
rest = get_lock_type(rest, &resp->r_lock_type);
if (rest == NULL)
goto fail;
rest =
get_longlong(rest, &resp->r_start, REQUIRES_MORE,
"Invalid lock start");
if (rest == NULL)
goto fail;
rest =
get_longlong(rest, &resp->r_length, REQUIRES_NO_MORE,
"Invalid lock length");
break;
case STATUS_CANCELED:
if (resp->r_cmd == CMD_LOCKW) {
rest = get_fpos(rest, &resp->r_fpos, REQUIRES_MORE);
if (rest == NULL)
goto fail;
rest = get_lock_type(rest, &resp->r_lock_type);
if (rest == NULL)
goto fail;
rest =
get_longlong(rest, &resp->r_start, REQUIRES_MORE,
"Invalid lock start");
if (rest == NULL)
goto fail;
rest =
get_longlong(rest, &resp->r_length,
REQUIRES_NO_MORE,
"Invalid lock length");
} else if (resp->r_cmd == CMD_ALARM) {
rest =
get_long(rest, &resp->r_secs, REQUIRES_NO_MORE,
"Invalid alarm time");
} else {
}
break;
case STATUS_COMPLETED:
break;
case STATUS_ERRNO:
rest =
get_long(rest, &resp->r_errno, REQUIRES_MORE,
"Invalid errno");
if (rest == NULL)
goto fail;
strncpy(resp->r_data, rest, MAXSTR);
rest += strlen(rest);
break;
case STATUS_PARSE_ERROR:
break;
case STATUS_ERROR:
break;
}
if (rest != NULL)
return rest;
fail:
resp->r_status = STATUS_PARSE_ERROR;
sprintf(resp->r_data, "%s %ld ERRNO %d \"%s\" \"%s\" bad token \"%s\"",
commands[resp->r_cmd].cmd_name, resp->r_tag, errno,
strerror(errno), errdetail, badtoken);
resp->r_cmd = NUM_COMMANDS;
return NULL;
}
void sprintf_resp(char *line, const char *lead, struct response *resp)
{
char *rest = line;
if (lead != NULL) {
const char *name = "<NULL>";
if (resp->r_client != NULL)
name = resp->r_client->c_name;
rest = rest + sprintf(line, "%s %s ", lead, name);
}
rest =
rest + sprintf(rest, "%ld %s %s", resp->r_tag,
commands[resp->r_cmd].cmd_name,
str_status(resp->r_status));
switch (resp->r_status) {
case STATUS_OK:
switch (resp->r_cmd) {
case CMD_COMMENT:
case CMD_HELLO:
sprintf(rest, " \"%s\"\n", resp->r_data);
break;
case CMD_LOCKW:
case CMD_LOCK:
case CMD_UNLOCK:
case CMD_TEST:
case CMD_LIST:
case CMD_HOP:
case CMD_UNHOP:
case NUM_COMMANDS:
sprintf(rest, " Unexpected Status\n");
break;
case CMD_ALARM:
sprintf(rest, " %ld\n", resp->r_secs);
break;
case CMD_QUIT:
sprintf(rest, "\n");
break;
case CMD_OPEN:
sprintf(rest, " %ld %ld\n", resp->r_fpos, resp->r_fno);
break;
case CMD_CLOSE:
case CMD_SEEK:
sprintf(rest, " %ld\n", resp->r_fpos);
break;
case CMD_WRITE:
sprintf(rest, " %ld %lld\n", resp->r_fpos,
resp->r_length);
break;
case CMD_READ:
sprintf(rest, " %ld %lld \"%s\"\n", resp->r_fpos,
resp->r_length, resp->r_data);
break;
}
break;
case STATUS_AVAILABLE:
case STATUS_GRANTED:
case STATUS_DENIED:
case STATUS_DEADLOCK:
if (resp->r_cmd == CMD_LIST)
sprintf(rest, " %ld %lld %lld\n", resp->r_fpos,
resp->r_start, resp->r_length);
else
sprintf(rest, " %ld %s %lld %lld\n", resp->r_fpos,
str_lock_type(resp->r_lock_type), resp->r_start,
resp->r_length);
break;
case STATUS_CONFLICT:
sprintf(rest, " %ld %ld %s %lld %lld\n", resp->r_fpos,
resp->r_pid, str_lock_type(resp->r_lock_type),
resp->r_start, resp->r_length);
break;
case STATUS_CANCELED:
if (resp->r_cmd == CMD_LOCKW) {
sprintf(rest, " %ld %s %lld %lld\n", resp->r_fpos,
str_lock_type(resp->r_lock_type), resp->r_start,
resp->r_length);
} else if (resp->r_cmd == CMD_ALARM) {
sprintf(rest, " %ld\n", resp->r_secs);
} else {
}
break;
case STATUS_COMPLETED:
sprintf(rest, "\n");
break;
case STATUS_ERRNO:
if (errno == 0)
sprintf(rest, " %ld \"%s\"\n", resp->r_errno,
errdetail);
else
sprintf(rest, " %ld \"%s\" \"%s\" bad token \"%s\"\n",
resp->r_errno, strerror(resp->r_errno),
errdetail, badtoken);
break;
case STATUS_PARSE_ERROR:
break;
case STATUS_ERROR:
break;
}
}
int compare_responses(struct response *expected, struct response *received)
{
errno = 0;
if (received == NULL) {
strcpy(errdetail, "Unexpected NULL response");
return false;
}
if (expected->r_client != received->r_client
&& strcmp(expected->r_client->c_name,
received->r_client->c_name) != 0) {
sprintf(errdetail, "Unexpected response from %s",
received->r_client->c_name);
return false;
}
if (expected->r_cmd != received->r_cmd) {
sprintf(errdetail, "Unexpected command %s",
commands[received->r_cmd].cmd_name);
return false;
}
return_if_ne_long(expected->r_tag, received->r_tag, "Unexpected tag");
if (expected->r_status != received->r_status) {
sprintf(errdetail, "Unexpected status %s",
str_status(received->r_status));
return false;
}
switch (expected->r_status) {
case STATUS_OK:
switch (expected->r_cmd) {
case CMD_COMMENT:
case CMD_HELLO:
/* could check string, but not worth it - HELLO has
* already set client name and that has been checked
*/
break;
case CMD_LOCKW:
case CMD_LOCK:
case CMD_UNLOCK:
case CMD_TEST:
case CMD_LIST:
case CMD_HOP:
case CMD_UNHOP:
case NUM_COMMANDS:
sprintf(errdetail, "Unexpected Status %s for %s",
str_status(received->r_status),
commands[received->r_cmd].cmd_name);
return false;
case CMD_ALARM:
return_if_ne_long(expected->r_secs, received->r_secs,
"Unexpected secs");
break;
case CMD_QUIT:
break;
case CMD_OPEN:
return_if_ne_long(expected->r_fpos, received->r_fpos,
"Unexpected fpos");
return_if_ne_long(expected->r_fno, received->r_fno,
"Unexpected file number");
break;
case CMD_CLOSE:
case CMD_SEEK:
return_if_ne_long(expected->r_fpos, received->r_fpos,
"Unexpected fpos");
break;
case CMD_WRITE:
return_if_ne_long(expected->r_fpos, received->r_fpos,
"Unexpected fpos");
return_if_ne_longlong(expected->r_length,
received->r_length,
"Unexpected length");
break;
case CMD_READ:
return_if_ne_long(expected->r_fpos, received->r_fpos,
"Unexpected fpos");
return_if_ne_longlong(expected->r_length,
received->r_length,
"Unexpected length");
return_if_ne_string(expected->r_data, received->r_data,
"Unexpected data");
break;
}
break;
case STATUS_AVAILABLE:
case STATUS_GRANTED:
case STATUS_DENIED:
case STATUS_DEADLOCK:
return_if_ne_long(expected->r_fpos, received->r_fpos,
"Unexpected fpos");
if (expected->r_cmd != CMD_LIST)
return_if_ne_lock_type(expected->r_lock_type,
received->r_lock_type);
return_if_ne_longlong(expected->r_start, received->r_start,
"Unexpected start");
return_if_ne_longlong(expected->r_length, received->r_length,
"Unexpected length");
break;
case STATUS_CONFLICT:
return_if_ne_long(expected->r_fpos, received->r_fpos,
"Unexpected fpos");
return_if_ne_long(expected->r_pid, received->r_pid,
"Unexpected pid");
return_if_ne_lock_type(expected->r_lock_type,
received->r_lock_type);
return_if_ne_longlong(expected->r_start, received->r_start,
"Unexpected start");
return_if_ne_longlong(expected->r_length, received->r_length,
"Unexpected length");
break;
case STATUS_CANCELED:
if (expected->r_cmd == CMD_LOCKW) {
return_if_ne_long(expected->r_fpos, received->r_fpos,
"Unexpected fpos");
return_if_ne_lock_type(expected->r_lock_type,
received->r_lock_type);
return_if_ne_longlong(expected->r_start,
received->r_start,
"Unexpected start");
return_if_ne_longlong(expected->r_length,
received->r_length,
"Unexpected length");
} else if (expected->r_cmd == CMD_ALARM) {
return_if_ne_long(expected->r_secs, received->r_secs,
"Unexpected secs");
} else {
}
break;
case STATUS_COMPLETED:
break;
case STATUS_ERRNO:
break;
case STATUS_PARSE_ERROR:
break;
case STATUS_ERROR:
break;
}
return true;
}
