int process_uevent_message(int socket)
{
char buffer[64 * 1024]; // Thank god we're not in the kernel :)
int count;
char *s = buffer;
char *end;
struct uevent *event;
int param_idx = 0;
int i;
int first = 1;
int rc = 0;
if ((count = recv(socket, buffer, sizeof(buffer), 0)) < 0) {
LOGE("Error receiving uevent (%s)", strerror(errno));
return -errno;
}
if (!(event = malloc(sizeof(struct uevent)))) {
LOGE("Error allocating memory (%s)", strerror(errno));
return -errno;
}
memset(event, 0, sizeof(struct uevent));
end = s + count;
while (s < end) {
if (first) {
char *p;
for (p = s; *p != '@'; p++);
p++;
event->path = strdup(p);
first = 0;
} else {
if (!strncmp(s, "ACTION=", strlen("ACTION="))) {
char *a = s + strlen("ACTION=");
if (!strcmp(a, "add"))
event->action = action_add;
else if (!strcmp(a, "change"))
event->action = action_change;
else if (!strcmp(a, "remove"))
event->action = action_remove;
} else if (!strncmp(s, "SEQNUM=", strlen("SEQNUM=")))
event->seqnum = atoi(s + strlen("SEQNUM="));
else if (!strncmp(s, "SUBSYSTEM=", strlen("SUBSYSTEM=")))
event->subsystem = strdup(s + strlen("SUBSYSTEM="));
else
event->param[param_idx++] = strdup(s);
}
s+= strlen(s) + 1;
}
check_uevent(event);
//dump_uevent(event);
free_uevent(event);
return 0;
}
int process_uevent_message(int sock)
{
char buffer[64 * 1024];
char *s = buffer, *p;
char *end;
int count, param_idx = 0, ret;
struct uevent *event;
count = recv(sock, buffer, sizeof(buffer), 0);
if (count < 0) {
LOGE("Error receiving uevent (%s)", strerror(errno));
return -errno;
}
event = malloc(sizeof(struct uevent));
if (!event) {
LOGE("Error allcating memroy (%s)", strerror(errno));
return -errno;
}
memset(event, 0, sizeof(struct uevent));
end = s + count;
for (p = s; *p != '@'; p++)
;
p++;
event->path = strdup(p);
s += strlen(s) + 1;
LOGE("UEVENT %s\n",s);
while (s < end) {
if (!strncmp(s, "ACTION=", strlen("ACTION="))) {
char *a = s + strlen("ACTION=");
if (!strcmp(a, "add"))
event->action = action_add;
else if (!strcmp(a, "change"))
event->action = action_change;
else if (!strcmp(a, "remove"))
event->action = action_remove;
} else if (!strncmp(s, "SEQNUM=", strlen("SEQNUM=")))
event->seqnum = atoi(s + strlen("SEQNUM="));
else if (!strncmp(s, "SUBSYSTEM=", strlen("SUBSYSTEM=")))
event->subsystem = strdup(s + strlen("SUBSYSTEM="));
else
event->param[param_idx++] = strdup(s);
s += strlen(s) + 1;
}
ret = dispatch_uevent(event);
#if DEBUG_UEVENT
dump_uevent(event);
#endif
free_uevent(event);
return ret;
}
int simulate_uevent(char *subsys, char *path, char *action, char **params)
{
struct uevent *event;
char tmp[255];
int i, rc;
if (!(event = malloc(sizeof(struct uevent)))) {
LOGE("Error allocating memory (%s)", strerror(errno));
return -errno;
}
memset(event, 0, sizeof(struct uevent));
event->subsystem = strdup(subsys);
if (!strcmp(action, "add"))
event->action = action_add;
else if (!strcmp(action, "change"))
event->action = action_change;
else if (!strcmp(action, "remove"))
event->action = action_remove;
else {
LOGE("Invalid action '%s'", action);
return -1;
}
event->path = strdup(path);
for (i = 0; i < UEVENT_PARAMS_MAX; i++) {
if (!params[i])
break;
event->param[i] = strdup(params[i]);
}
rc = dispatch_uevent(event);
free_uevent(event);
return rc;
}
static struct uevents *read_sysfs_uevents(char *dname)
{
FILE *fp;
struct uevents *next, *uevent;
char *event = "uevent", *file, s[4096];
next = uevent = calloc(1, sizeof(*uevent));
file = malloc(strlen(dname) + strlen(event) + 1);
strcpy(file, dname);
strcat(file, event);
if (debug)
fprintf(stderr, "Parsing uevent %s\n", file);
fp = fopen(file, "r");
if (!fp) {
perror(file);
free(file);
return NULL;
}
while (fgets(s, sizeof(s), fp)) {
char *p = strtok(s, "=");
if (!p)
continue;
next->key = malloc(strlen(p) + 1);
if (!next->key) {
perror("next->key");
free(file);
free_uevent(uevent);
return NULL;
}
strcpy(next->key, p);
p = strtok(NULL, "\n");
if (!p) {
fprintf(stderr, "Error on uevent information\n");
fclose(fp);
free(file);
free_uevent(uevent);
return NULL;
}
next->value = malloc(strlen(p) + 1);
if (!next->value) {
perror("next->value");
free(file);
free_uevent(uevent);
return NULL;
}
strcpy(next->value, p);
if (debug)
fprintf(stderr, "%s uevent %s=%s\n", file, next->key, next->value);
next->next = calloc(1, sizeof(*next));
if (!next->next) {
perror("next->next");
free(file);
free_uevent(uevent);
return NULL;
}
next = next->next;
}
fclose(fp);
free(file);
return uevent;
}
static int get_attribs(struct rc_device *rc_dev, char *sysfs_name)
{
struct uevents *uevent;
char *input = "input", *event = "event";
char *DEV = "/dev/";
static struct sysfs_names *input_names, *event_names, *attribs, *cur;
/* Clean the attributes */
memset(rc_dev, 0, sizeof(*rc_dev));
rc_dev->sysfs_name = sysfs_name;
input_names = seek_sysfs_dir(rc_dev->sysfs_name, input);
if (!input_names)
return EINVAL;
if (input_names->next->next) {
fprintf(stderr, "Found more than one input interface."
"This is currently unsupported\n");
return EINVAL;
}
if (debug)
fprintf(stderr, "Input sysfs node is %s\n", input_names->name);
event_names = seek_sysfs_dir(input_names->name, event);
free_names(input_names);
if (!event_names) {
free_names(event_names);
return EINVAL;
}
if (event_names->next->next) {
free_names(event_names);
fprintf(stderr, "Found more than one event interface."
"This is currently unsupported\n");
return EINVAL;
}
if (debug)
fprintf(stderr, "Event sysfs node is %s\n", event_names->name);
uevent = read_sysfs_uevents(event_names->name);
free_names(event_names);
if (!uevent)
return EINVAL;
while (uevent->next) {
if (!strcmp(uevent->key, "DEVNAME")) {
rc_dev->input_name = malloc(strlen(uevent->value) + strlen(DEV) + 1);
strcpy(rc_dev->input_name, DEV);
strcat(rc_dev->input_name, uevent->value);
break;
}
uevent = uevent->next;
}
free_uevent(uevent);
if (!rc_dev->input_name) {
fprintf(stderr, "Input device name not found.\n");
return EINVAL;
}
uevent = read_sysfs_uevents(rc_dev->sysfs_name);
if (!uevent)
return EINVAL;
while (uevent->next) {
if (!strcmp(uevent->key, "DRV_NAME")) {
rc_dev->drv_name = malloc(strlen(uevent->value) + 1);
strcpy(rc_dev->drv_name, uevent->value);
}
if (!strcmp(uevent->key, "NAME")) {
rc_dev->keytable_name = malloc(strlen(uevent->value) + 1);
strcpy(rc_dev->keytable_name, uevent->value);
}
uevent = uevent->next;
}
free_uevent(uevent);
if (debug)
fprintf(stderr, "input device is %s\n", rc_dev->input_name);
sysfs++;
rc_dev->type = SOFTWARE_DECODER;
/* Get the other attribs - basically IR decoders */
attribs = seek_sysfs_dir(rc_dev->sysfs_name, NULL);
for (cur = attribs; cur->next; cur = cur->next) {
if (!cur->name)
continue;
if (strstr(cur->name, "/protocols")) {
rc_dev->version = VERSION_2;
rc_dev->type = UNKNOWN_TYPE;
v2_get_protocols(rc_dev, cur->name);
} else if (strstr(cur->name, "/protocol")) {
rc_dev->version = VERSION_1;
rc_dev->type = HARDWARE_DECODER;
rc_dev->current = v1_get_hw_protocols(cur->name);
} else if (strstr(cur->name, "/supported_protocols")) {
rc_dev->version = VERSION_1;
rc_dev->supported = v1_get_hw_protocols(cur->name);
} else if (strstr(cur->name, "/nec_decoder")) {
rc_dev->supported |= NEC;
if (v1_get_sw_enabled_protocol(cur->name))
rc_dev->current |= NEC;
} else if (strstr(cur->name, "/rc5_decoder")) {
rc_dev->supported |= RC_5;
if (v1_get_sw_enabled_protocol(cur->name))
rc_dev->current |= RC_5;
} else if (strstr(cur->name, "/rc6_decoder")) {
rc_dev->supported |= RC_6;
if (v1_get_sw_enabled_protocol(cur->name))
rc_dev->current |= RC_6;
} else if (strstr(cur->name, "/jvc_decoder")) {
rc_dev->supported |= JVC;
if (v1_get_sw_enabled_protocol(cur->name))
rc_dev->current |= JVC;
} else if (strstr(cur->name, "/sony_decoder")) {
rc_dev->supported |= SONY;
if (v1_get_sw_enabled_protocol(cur->name))
rc_dev->current |= SONY;
} else if (strstr(cur->name, "/xmp_decoder")) {
rc_dev->supported |= XMP;
if (v1_get_sw_enabled_protocol(cur->name))
rc_dev->current |= XMP;
}
}
return 0;
}
