bool CTSimObj::detectEntities(EntityNameC &v, int id) { NSLookup::Provider *prov = lookupProvider(Service::DETECT_ENTITIES); if (!prov) { LOG_ERR(("detectEntities : cannot get service provider info [%s:%d]", __FILE__, __LINE__)); return false; } SOCKET sock = prov->sock(); if (sock < 0) { LOG_ERR(("detectEntities : cannot connect to service provider [%s:%d]", __FILE__, __LINE__)); return false; } CommRequestDetectEntitiesEncoder enc(myname(), id); #if 1 // modified by sekikawa on 2010-08-26 for confirmation // // Call prov->close() when a socket error arises between service provider // to set socket ID held by prov should be -1. // // If the prov->close() is not called before the exit of this method, // lookupProvider() might return a socket ID which is unvalid. // // In the last of this method, prov->close() will be called before the modification; // however, the error treatment is added for confirmation. if (enc.send(sock) < 0) { prov->close(); return false; } #else // orig enc.send(sock); #endif CommDataDecoder d; typedef CTReader Reader; Reader r(sock, d, 8192); #if 1 // retry version (added by sekikawa)(2009/03/13) bool ret = false; int retry = 5; int timeout = 10000; while (retry > 0) { #if 1 // sekikawa(FIX20100906) Result *result = NULL; try { result = r.readSync(); } catch(CTReader::ConnectionClosedException &e) { break; } #else // orig Result *result = r.readSync(); #endif if (result) { if (result->type() == COMM_RESULT_DETECT_ENTITIES) { ResultDetectEntitiesEvent *evt = (ResultDetectEntitiesEvent*) result->data(); evt->copy(v); ret = true; } delete result; break; } else { retry--; #ifdef WIN32 Sleep(timeout); #else usleep(timeout); #endif timeout *= 2; } } #else // original version Result *result = r.readSync(); bool ret = false; if (result) { if (result->type() == COMM_RESULT_DETECT_ENTITIES) { ResultDetectEntitiesEvent *evt = (ResultDetectEntitiesEvent*) result->data(); evt->copy(v); ret = true; } delete result; } #endif prov->close(); return ret; }
int port_init( struct port * port, struct ipcm * owner, portid id, struct ae * ae, struct ipcp * upper, struct ipcp * lower) { int status = SUCCESS; if(!port || !lower) { LOG_WARNING("Wrong args, port=0x%pK, lower=%pK", port, lower); return ERR_PORT_INIT_WRONG_ARGS; } if(!PORT_IS_VALID_ID(id)) { LOG_WARNING("Invalid port id, id=%d", id); return ERR_PORT_INIT_INVALID_ID; } port->id = id; port->owner = owner; port->ae = ae; port->upper = upper; port->lower = lower; RNSLIST_INIT_HEAD(&port->listh); rnspin_lock_init(&port->lock); /* * Inform ipcps about the event. * * Why does lower ipcp come before the upper one? Nice question, and * here your answer: lower ipcp must evaluate if it can somehow grant * that the upper ipcp qoses are respected (if the model say so), and so * is probably the main source of failure. * At the end is the lower ipcp which grant communication. */ if(port->lower->model->ops->port_created) { status = port->lower->model->ops->port_created( port->lower, port); } if(status) { LOG_WARNING("Lower ipcp decided to abort port creation, " "port=%d, negator=%d", port->id, port->lower->id); return status; } /* Case ipcp over ipcp. */ if(!PORT_AE_IS_UPPER(port)) { if(port->upper->model->ops->port_created) { status = port->upper->model->ops->port_created( port->upper, port); } if(status) { LOG_WARNING("Upper ipcp decided to abort port creation," " port=%d, negator=%d", port->id, port->upper->id); /* Roll-back of previous actions */ port->lower->model->ops->port_released( port->lower, port); return status; } } #ifdef RNS_SYSFS status = kobject_init_and_add( &port->kobj, &port_sys_ktype, &owner->kobj_p, "%d", port->id); if(status) { LOG_ERR("Ipcp sysfs failure, status=%d", status); return ERR_PORT_INIT_SYSFS; } #endif /* RNS_SYSFS */ LOG_DBG("Port initialized, id=%d", port->id); return status; }
static int serval_inet_tcp_init_sock(struct sock *sk) { struct socket *sock = sk->sk_socket; struct sock *old_sk = sk; const struct proto_ops *old_ops = sock->ops; struct inet_sock *inet; int err = 0; LOG_DBG("init sock\n"); /* First fully initialize the old sock. Otherwise, the release function will fail. */ err = old_tcp_prot.init(sk); if (err) return err; sock->ops = &serval_inet_stream_ops; sk = serval_sk_alloc(sock_net(sk), sock, GFP_KERNEL, SERVAL_PROTO_TCP, &serval_tcp_proto); if (!sk) { LOG_ERR("Fail alloc\n"); goto out_fail_alloc; } /* Initialize serval sock part of socket */ serval_sock_init(sk); /* Initialize inet part */ inet = inet_sk(sk); inet->uc_ttl = -1; /* Let IP decide TTL */ inet->mc_loop = 1; inet->mc_ttl = 1; inet->mc_index = 0; inet->mc_list = NULL; if (sk->sk_prot->init) { /* Call protocol specific init */ err = sk->sk_prot->init(sk); if (err < 0) { LOG_ERR("Fail init\n"); goto out_fail_init; } } sock_hold(old_sk); serval_sk(sk)->old_sk = old_sk; LOG_DBG("Successfully hijacked sock\n"); return 0; out_fail_init: sk_common_release(sk); out_fail_alloc: sock->ops = old_ops; sock->sk = old_sk; return 0; }
static int ctrl_handle_add_service_msg(struct ctrlmsg *cm, int peer) { struct ctrlmsg_service *cmr = (struct ctrlmsg_service *)cm; unsigned int num_res = CTRLMSG_SERVICE_NUM(cmr); /* TODO - flags, etc */ unsigned int i, index = 0; int err = 0; LOG_DBG("adding %u services, msg size %u\n", num_res, CTRLMSG_SERVICE_LEN(cmr)); for (i = 0; i < num_res; i++) { struct net_device *dev = NULL; struct service_info *entry = &cmr->service[i]; unsigned short prefix_bits = SERVICE_ID_MAX_PREFIX_BITS; if (entry->type == SERVICE_RULE_FORWARD) { dev = resolve_dev(entry); if (!dev) continue; } if (entry->srvid_prefix_bits > 0) prefix_bits = entry->srvid_prefix_bits; #if defined(ENABLE_DEBUG) { char ipstr[18]; LOG_DBG("Adding service id: %s(%u) " "@ address %s, priority %u, weight %u\n", service_id_to_str(&entry->srvid), prefix_bits, inet_ntop(AF_INET, &entry->address, ipstr, sizeof(ipstr)), entry->priority, entry->weight); } #endif err = service_add(&entry->srvid, prefix_bits, entry->type, entry->srvid_flags, entry->priority, entry->weight, &entry->address, sizeof(entry->address), make_target(dev), GFP_KERNEL); if (dev) dev_put(dev); if (err > 0) { if (index < i) { /* copy it over */ memcpy(&cmr->service[index], entry, sizeof(*entry)); } index++; } else { LOG_ERR("Error adding service %s: err=%d\n", service_id_to_str(&entry->srvid), err); } } if (index == 0) { /* Just return the original request with a return value */ cm->retval = CTRLMSG_RETVAL_NOENTRY; } else { /* Return the entries added */ cm->retval = CTRLMSG_RETVAL_OK; cm->len = CTRLMSG_SERVICE_NUM_LEN(index); } ctrl_sendmsg(cm, peer, GFP_KERNEL); return 0; }
/* ------------------------------------------------------------------------------ */ static int SYSRAM_Flush(struct file *pFile, fl_owner_t Id) { MUINT32 Index = 0; MUINT32 Sec = 0, USec = 0; MUINT64 Time64 = 0; SYSRAM_PROC_STRUCT *pProc; /* */ SYSRAM_GetTime(&Time64, &Sec, &USec); /* */ LOG_MSG("Cur:Name(%s),pid(%d),tgid(%d),Time(%ld.%06ld)", current->comm, current->pid, current->tgid, Sec, USec); /* */ if (pFile->private_data != NULL) { pProc = (SYSRAM_PROC_STRUCT *) pFile->private_data; /* */ if (pProc->Pid != 0 || pProc->Tgid != 0 || pProc->Table != 0) { /* */ LOG_WRN("Proc:Name(%s),pid(%d),tgid(%d),Table(0x%08lX),Time(%ld.%06ld)", pProc->ProcName, pProc->Pid, pProc->Tgid, pProc->Table, pProc->TimeS, pProc->TimeUS); /* */ if (pProc->Tgid == 0 && pProc->Table != 0) { LOG_ERR("No Tgid info"); /* LOG_ERR("Cur:Name(%s),pid(%d),tgid(%d),Time(%ld.%06ld)", current->comm, current->pid, current->tgid, Sec, USec); LOG_ERR("Proc:Name(%s),pid(%d),tgid(%d),Table(0x%08lX),Time(%ld.%06ld)", pProc->ProcName, pProc->Pid, pProc->Tgid, pProc->Table, pProc->TimeS, pProc->TimeUS); */ } else if ((pProc->Tgid == current->tgid) || ((pProc->Tgid != current->tgid) && (strcmp(current->comm, "binder") == 0))) { if (pProc->Table) { LOG_WRN("Force to release"); /* LOG_WRN("Cur:Name(%s),pid(%d),tgid(%d),Time(%ld.%06ld)", current->comm, current->pid, current->tgid, Sec, USec); */ SYSRAM_DumpLayout(); /* */ for (Index = 0; Index < SYSRAM_USER_AMOUNT; Index++) { /**/ if (pProc->Table & (1 << Index)) { SYSRAM_IOC_Free((SYSRAM_USER_ENUM) Index); } } /* */ pProc->Table = 0; } } } } else { LOG_WRN("private_data is NULL"); /* LOG_WRN("Cur:Name(%s),pid(%d),tgid(%d),Time(%ld.%06ld)", current->comm, current->pid, current->tgid, Sec, USec); */ } /* */ return 0; }
static int fbw_parse_buffer( const uint8_t *buf, int len, struct wedge_eeprom_st *eeprom) { int rc = 0; const uint8_t* cur = buf; uint16_t magic; int crc_len; uint8_t crc8; memset(eeprom, 0, sizeof(*eeprom)); /* make sure the magic number */ fbw_copy_uint16(&magic, &cur, FBW_EEPROM_F_MAGIC); if (magic != 0xfbfb) { rc = EFAULT; LOG_ERR(rc, "Unexpected magic word 0x%x", magic); goto out; } /* confirm the version number, only version is supported */ fbw_copy_uint8(&eeprom->fbw_version, &cur, FBW_EEPROM_F_VERSION); if ((eeprom->fbw_version != FBW_EEPROM_VERSION0) && (eeprom->fbw_version != FBW_EEPROM_VERSION1) && (eeprom->fbw_version != FBW_EEPROM_VERSION2)) { rc = EFAULT; LOG_ERR(rc, "Unsupported version number %u", eeprom->fbw_version); goto out; } else { if (eeprom->fbw_version == FBW_EEPROM_VERSION0) { crc_len = FBW_EEPROM_V0_SIZE; } else if (eeprom->fbw_version == FBW_EEPROM_VERSION1) { crc_len = FBW_EEPROM_V1_SIZE; } else if (eeprom->fbw_version == FBW_EEPROM_VERSION2) { crc_len = FBW_EEPROM_V2_SIZE; } assert(crc_len <= len); } /* check CRC */ crc8 = fbw_crc8_buf(buf, crc_len); if (crc8 != 0) { rc = EFAULT; LOG_ERR(rc, "CRC check failed"); goto out; } /* Product name: ASCII for 12 characters */ fbw_strcpy(eeprom->fbw_product_name, sizeof(eeprom->fbw_product_name), &cur, FBW_EEPROM_F_PRODUCT_NAME); /* Product Part #: 8 byte data shown as XX-XXXXXXX */ fbw_copy_product_number(eeprom->fbw_product_number, sizeof(eeprom->fbw_product_number), &cur, FBW_EEPROM_F_PRODUCT_NUMBER); /* System Assembly Part Number: XXX-XXXXXX-XX */ fbw_copy_assembly_number(eeprom->fbw_assembly_number, sizeof(eeprom->fbw_assembly_number), &cur, FBW_EEPROM_F_ASSEMBLY_NUMBER); /* Facebook PCBA Part Number: XXX-XXXXXXX-XX */ fbw_copy_facebook_pcb_part(eeprom->fbw_facebook_pcba_number, sizeof(eeprom->fbw_facebook_pcba_number), &cur, FBW_EEPROM_F_FACEBOOK_PCBA_NUMBER); /* Facebook PCBA Part Number: XXX-XXXXXXX-XX */ if (eeprom->fbw_version >= FBW_EEPROM_VERSION1) { fbw_copy_facebook_pcb_part(eeprom->fbw_facebook_pcb_number, sizeof(eeprom->fbw_facebook_pcb_number), &cur, FBW_EEPROM_F_FACEBOOK_PCB_NUMBER); } /* ODM PCBA Part Number: XXXXXXXXXXXX */ fbw_strcpy(eeprom->fbw_odm_pcba_number, sizeof(eeprom->fbw_odm_pcba_number), &cur, FBW_EEPROM_F_ODM_PCBA_NUMBER); /* ODM PCBA Serial Number: XXXXXXXXXXXX */ fbw_strcpy(eeprom->fbw_odm_pcba_serial, sizeof(eeprom->fbw_odm_pcba_serial), &cur, (eeprom->fbw_version >= FBW_EEPROM_VERSION2) ? FBW_EEPROM_F_ODM_PCBA_SERIAL_V2 : FBW_EEPROM_F_ODM_PCBA_SERIAL); /* Product Production State */ fbw_copy_uint8(&eeprom->fbw_production_state, &cur, FBW_EEPROM_F_PRODUCT_STATE); /* Product Version */ fbw_copy_uint8(&eeprom->fbw_product_version, &cur, FBW_EEPROM_F_PRODUCT_VERSION); /* Product Sub Version */ fbw_copy_uint8(&eeprom->fbw_product_subversion, &cur, FBW_EEPROM_F_PRODUCT_SUBVERSION); /* Product Serial Number: XXXXXXXX */ fbw_strcpy(eeprom->fbw_product_serial, sizeof(eeprom->fbw_product_serial), &cur, (eeprom->fbw_version >= FBW_EEPROM_VERSION2) ? FBW_EEPROM_F_PRODUCT_SERIAL_V2 : FBW_EEPROM_F_PRODUCT_SERIAL); /* Product Assert Tag: XXXXXXXX */ fbw_strcpy(eeprom->fbw_product_asset, sizeof(eeprom->fbw_product_asset), &cur, FBW_EEPROM_F_PRODUCT_ASSET); /* System Manufacturer: XXXXXXXX */ fbw_strcpy(eeprom->fbw_system_manufacturer, sizeof(eeprom->fbw_system_manufacturer), &cur, FBW_EEPROM_F_SYSTEM_MANUFACTURER); /* System Manufacturing Date: mm-dd-yy */ fbw_copy_date(eeprom->fbw_system_manufacturing_date, sizeof(eeprom->fbw_system_manufacturing_date), &cur, FBW_EEPROM_F_SYSTEM_MANU_DATE); /* PCB Manufacturer: XXXXXXXXX */ fbw_strcpy(eeprom->fbw_pcb_manufacturer, sizeof(eeprom->fbw_pcb_manufacturer), &cur, FBW_EEPROM_F_PCB_MANUFACTURER); /* Assembled At: XXXXXXXX */ fbw_strcpy(eeprom->fbw_assembled, sizeof(eeprom->fbw_assembled), &cur, FBW_EEPROM_F_ASSEMBLED); /* Local MAC Address */ fbw_copy_mac(eeprom->fbw_local_mac, sizeof(eeprom->fbw_local_mac), &cur, FBW_EEPROM_F_LOCAL_MAC); /* Extended MAC Address */ fbw_copy_mac(eeprom->fbw_mac_base, sizeof(eeprom->fbw_mac_base), &cur, FBW_EEPROM_F_EXT_MAC_BASE); /* Extended MAC Address Size */ fbw_copy_uint16(&eeprom->fbw_mac_size, &cur,FBW_EEPROM_F_EXT_MAC_SIZE); /* Location on Fabric: "LEFT"/"RIGHT", "WEDGE", "LC" */ fbw_strcpy(eeprom->fbw_location, sizeof(eeprom->fbw_location), &cur, FBW_EEPROM_F_LOCATION); /* CRC8 */ fbw_copy_uint8(&eeprom->fbw_crc8, &cur, FBW_EEPROM_F_CRC8); assert((cur - buf) <= len); out: return rc; }
static int ctrl_handle_del_service_msg(struct ctrlmsg *cm, int peer) { struct ctrlmsg_service *cmr = (struct ctrlmsg_service *)cm; unsigned int num_res = CTRLMSG_SERVICE_NUM(cmr); const size_t cmsg_size = sizeof(struct ctrlmsg_service_info_stat) + sizeof(struct service_info_stat) * num_res; struct ctrlmsg_service_info_stat *cms; struct service_id null_service = { .s_sid = { 0 } }; unsigned int i = 0, index = 0; int err = 0; LOG_DBG("deleting %u services\n", num_res); cms = kmalloc(cmsg_size, GFP_KERNEL); if (!cms) { cm->retval = CTRLMSG_RETVAL_ERROR; ctrl_sendmsg(cm, peer, GFP_KERNEL); return -ENOMEM; } memset(cms, 0, cmsg_size); for (i = 0; i < num_res; i++) { struct service_info *entry = &cmr->service[i]; struct service_info_stat *stat = &cms->service[index]; struct target_stats tstat; struct service_entry *se; unsigned short prefix_bits = SERVICE_ID_MAX_PREFIX_BITS; /* We might be trying to delete the "default" entry. In that case */ if (memcmp(&entry->srvid, &null_service, sizeof(null_service)) == 0 || entry->srvid_prefix_bits > 0) prefix_bits = entry->srvid_prefix_bits; stat->service.srvid_prefix_bits = prefix_bits; se = service_find_exact(&entry->srvid, prefix_bits); if (!se) { LOG_DBG("No match for serviceID %s:(%u)\n", service_id_to_str(&entry->srvid), prefix_bits); continue; } memset(&tstat, 0, sizeof(tstat)); err = service_entry_remove_target(se, entry->type, &entry->address, sizeof(entry->address), &tstat); if (err > 0) { stat->duration_sec = tstat.duration_sec; stat->duration_nsec = tstat.duration_nsec; stat->packets_resolved = tstat.packets_resolved; stat->bytes_resolved = tstat.bytes_resolved; stat->packets_dropped = tstat.packets_dropped; stat->bytes_dropped = tstat.packets_dropped; //if (index < i) { memcpy(&stat->service, entry, sizeof(*entry)); //} LOG_DBG("Service ID %s:%u\n", service_id_to_str(&stat->service.srvid), stat->service.srvid_prefix_bits); index++; } else if (err == 0) { LOG_ERR("Could not find target for service %s\n", service_id_to_str(&entry->srvid)); } else { LOG_ERR("Could not remove service %s - err %d\n", service_id_to_str(&entry->srvid), err); } service_entry_put(se); } if (index == 0) { cm->retval = CTRLMSG_RETVAL_NOENTRY; ctrl_sendmsg(cm, peer, GFP_KERNEL); } else { cms->cmh.type = CTRLMSG_TYPE_DEL_SERVICE; cms->xid = cmr->xid; cms->cmh.xid = cm->xid; cms->cmh.retval = CTRLMSG_RETVAL_OK; cms->cmh.len = CTRLMSG_SERVICE_INFO_STAT_NUM_LEN(index); ctrl_sendmsg(&cms->cmh, peer, GFP_KERNEL); } kfree(cms); return 0; }
/** * Check if config directory exists; if not create it and set config_dir * @return TRUE if it completed successfully or FALSE otherwise */ bool configfile_check_dir (void) { Uint32 length; #ifndef _WIN32 DIR *dir = NULL; #endif if (config_dir == NULL) { /* Determines the size of the string of the directory * and allocates memory */ length = strlen (config_filename) + 3; #ifdef _WIN32 length++; #else if (getenv ("XDG_CONFIG_HOME") != NULL) { length += strlen (getenv ("XDG_CONFIG_HOME")) + 1; } else { if (getenv ("HOME") != NULL) { length += strlen (getenv ("HOME")); } else { length++; } length += strlen ("/.config") + 1; } #endif config_dir = memory_allocation (length); if (config_dir == NULL) { LOG_ERR ("not enough memory to allocate %i bytes!", length); return FALSE; } } #ifdef _WIN32 _snprintf (config_dir, strlen (config_dir) - 1, "./%s", config_filename); /* create directory if not exist */ create_dir (config_dir); #else if (getenv ("XDG_CONFIG_HOME") != NULL) { snprintf (config_dir, strlen (config_dir) - 1, "%s/%s", getenv ("XDG_CONFIG_HOME"), config_filename); } else { snprintf (config_dir, strlen (config_dir) - 1, "%s/.config/%s", (getenv ("HOME") ? getenv ("HOME") : "."), config_filename); } /* test and create .tlkgames */ dir = opendir (config_dir); if (dir == NULL) { LOG_WARN ("couldn't find/open config directory '%s'", config_dir); LOG_WARN ("attempting to create it..."); create_dir (config_dir); if (!opendir (config_dir)) { LOG_ERR ("opendir(%s) fail", config_dir); return FALSE; } else { LOG_INF ("opendir(%s) successful", config_dir); } } else { closedir (dir); dir = NULL; } #endif return TRUE; }
/** * Load configuration file from "~/.tlkgames/powermanga.conf" * @return TRUE if it completed successfully or FALSE otherwise */ bool configfile_load (void) { #if !defined(_WIN32_WCE) Uint32 length; #endif lisp_object_t *root_obj, *lst, *sub; char *str; /* allocate config structure */ if (power_conf == NULL) { power_conf = (config_file *) memory_allocation (sizeof (config_file)); if (power_conf == NULL) { LOG_ERR ("not enough memory to allocate 'power_conf'!"); return FALSE; } } configfile_reset_values (); if (!configfile_check_dir ()) { return TRUE; } if (configname == NULL) { #if defined(_WIN32_WCE) configname = locate_data_file (config_file_name); if (configname == NULL) { LOG_ERR ("can't locate file: %s", config_file_name); return FALSE; } #else length = strlen (config_dir) + strlen (config_file_name) + 2; configname = memory_allocation (length); if (configname == NULL) { LOG_ERR ("not enough memory to allocate %i bytes!", length); return FALSE; } #endif } sprintf (configname, "%s/%s", config_dir, config_file_name); LOG_INF ("configuration filename: %s", configname); root_obj = lisp_read_file (configname); if (root_obj == NULL) { LOG_ERR ("lisp_read_file(%s) failed!", configname); return TRUE; } if (root_obj->type == LISP_TYPE_EOF || root_obj->type == LISP_TYPE_PARSE_ERROR) { LOG_ERR ("lisp_read_file(%s) failed!", configname); lisp_free (root_obj); return TRUE; } if (strcmp (lisp_symbol (lisp_car (root_obj)), "powermanga-config") != 0) { LOG_ERR ("lisp_read_file(%s) failed!", configname); lisp_free (root_obj); return TRUE; } lst = lisp_cdr (root_obj); if (!lisp_read_string (lst, "lang", &str)) { power_conf->lang = EN_LANG; } else { if (strcmp (str, "fr") == 0) { power_conf->lang = FR_LANG; } else if (strcmp (str, "it") == 0) { power_conf->lang = IT_LANG; } else { power_conf->lang = EN_LANG; } } if (!lisp_read_bool (lst, "fullscreen", &power_conf->fullscreen)) { power_conf->fullscreen = TRUE; } if (!lisp_read_bool (lst, "nosound", &power_conf->nosound)) { power_conf->nosound = FALSE; } if (!lisp_read_bool (lst, "nosync", &power_conf->nosync)) { power_conf->nosync = FALSE; } if (!lisp_read_int (lst, "verbose", &power_conf->verbose)) { power_conf->verbose = 0; } if (!lisp_read_int (lst, "scale_x", &power_conf->scale_x)) { power_conf->scale_x = 2; } if (power_conf->scale_x < 1 || power_conf->scale_x > 4) { power_conf->scale_x = 2; } if (!lisp_read_int (lst, "resolution", &power_conf->resolution)) { power_conf->resolution = 640; } if (power_conf->resolution != 320 && power_conf->resolution != 640) { power_conf->resolution = 640; } if (power_conf->scale_x > 1) { power_conf->resolution = 640; } sub = search_for (lst, "joy_config"); if (sub) sub = lisp_car_int (sub, &power_conf->joy_x_axis); if (sub) sub = lisp_car_int (sub, &power_conf->joy_y_axis); if (sub) sub = lisp_car_int (sub, &power_conf->joy_fire); if (sub) sub = lisp_car_int (sub, &power_conf->joy_option); if (sub) sub = lisp_car_int (sub, &power_conf->joy_start); lisp_free (root_obj); configfile_print(); return TRUE; }
static struct pdu_ser * pdu_serialize_gfp(gfp_t flags, const const struct serdes * instance, struct pdu * pdu) { struct pdu_ser * tmp; struct dt_cons * dt_cons; const void * buffer_data; const struct buffer * buffer; const struct pci * pci; size_t size; ssize_t buffer_size; ssize_t pci_size; char * data; pdu_type_t pdu_type; seq_num_t seq; struct buffer * buf; if (!pdu_is_ok(pdu)) return NULL; if (!instance) return NULL; dt_cons = instance->dt_cons; ASSERT(dt_cons); buffer = pdu_buffer_get_ro(pdu); if (!buffer) return NULL; buffer_data = buffer_data_ro(buffer); if (!buffer_data) return NULL; buffer_size = buffer_length(buffer); if (buffer_size <= 0) return NULL; pci = pdu_pci_get_ro(pdu); if (!pci) return NULL; pdu_type = pci_type(pci); if (!pdu_type_is_ok(pdu_type)) { LOG_ERR("Wrong PDU type"); return NULL; } /* Base PCI size, fields present in all PDUs */ pci_size = base_pci_size(dt_cons); /* * These are available in the stack at this point in time * Extend if necessary (e.g.) NACKs, SACKs, ... * Set size in first switch/case */ switch (pdu_type) { case PDU_TYPE_MGMT: case PDU_TYPE_DT: size = pci_size + dt_cons->seq_num_length + buffer_size; if (size <= 0) return NULL; break; case PDU_TYPE_FC: size = pci_size + CTRL_SEQ_NR + fc_pci_size(dt_cons); if (size <= 0) return NULL; break; case PDU_TYPE_ACK: size = pci_size + CTRL_SEQ_NR + dt_cons->seq_num_length; if (size <= 0) return NULL; break; case PDU_TYPE_ACK_AND_FC: size = pci_size + CTRL_SEQ_NR + fc_pci_size(dt_cons) + dt_cons->seq_num_length; if (size <= 0) return NULL; break; case PDU_TYPE_CC: size = pci_size + 2 * CTRL_SEQ_NR + 4 * dt_cons->seq_num_length + RATE_LEN; if (size <= 0) return NULL; break; default: LOG_ERR("Unknown PDU type %02X", pdu_type); return NULL; } data = rkmalloc(size, flags); if (!data) return NULL; /* Needed for all PDUs */ if (serialize_base_pci(instance, data, pci, size)) { LOG_ERR("Failed to serialize base PCI"); rkfree(data); return NULL; } /* Do actual serializing in the second switch case */ switch (pdu_type) { case PDU_TYPE_MGMT: case PDU_TYPE_DT: seq = pci_sequence_number_get(pci); memcpy(data + pci_size, &seq, dt_cons->seq_num_length); memcpy(data + pci_size + dt_cons->seq_num_length, buffer_data, buffer_size); break; case PDU_TYPE_FC: if (serialize_ctrl_seq(instance, data, pci, pci_size) || serialize_fc_pci(instance, data, pci, pci_size + CTRL_SEQ_NR)) { rkfree(data); return NULL; } break; case PDU_TYPE_ACK: if (serialize_ctrl_seq(instance, data, pci, pci_size) || serialize_ack_pci(instance, data, pci, pci_size + CTRL_SEQ_NR)) { rkfree(data); return NULL; } break; case PDU_TYPE_ACK_AND_FC: if (serialize_ctrl_seq(instance, data, pci, pci_size) || serialize_ack_pci(instance, data, pci, pci_size + CTRL_SEQ_NR) || serialize_fc_pci(instance, data, pci, pci_size + CTRL_SEQ_NR + dt_cons->seq_num_length)) { rkfree(data); return NULL; } break; case PDU_TYPE_CC: if (serialize_ctrl_seq(instance, data, pci, pci_size) || serialize_cc_pci(instance, data, pci, pci_size + CTRL_SEQ_NR)) { rkfree(data); return NULL; } break; default: LOG_ERR("Unknown PDU type %02X", pdu_type); return NULL; } buf = buffer_create_with_gfp(flags, data, size); if (!buf) { rkfree(data); return NULL; } tmp = pdu_ser_create_buffer_with_gfp(flags, buf); if (!tmp) { rkfree(buf); return NULL; } #ifdef CONFIG_RINA_IPCPS_TTL if (pdu_ser_head_grow(tmp, sizeof(u8))) { LOG_ERR("Failed to grow ser PDU"); pdu_ser_destroy(tmp); return NULL; } if (!dup_ttl_set(tmp, pci_ttl(pci))) { LOG_ERR("Could not set TTL"); pdu_ser_destroy(tmp); return NULL; } if (dup_ttl_is_expired(tmp)) { LOG_DBG("TTL is expired, dropping PDU"); pdu_ser_destroy(tmp); return NULL; } #endif #ifdef CONFIG_RINA_IPCPS_CRC /* Assuming CRC32 */ if (pdu_ser_head_grow(tmp, sizeof(u32))) { LOG_ERR("Failed to grow ser PDU"); pdu_ser_destroy(tmp); return NULL; } if (!dup_chksum_set(tmp)) { LOG_ERR("Failed to add CRC"); pdu_ser_destroy(tmp); return NULL; } ASSERT(dup_chksum_is_ok(tmp)); #endif pdu_destroy(pdu); return tmp; }
static struct pdu * pdu_deserialize_gfp(gfp_t flags, const struct serdes * instance, struct pdu_ser * pdu) { struct pdu * new_pdu; struct dt_cons * dt_cons; const struct buffer * tmp_buff; struct buffer * new_buff; struct pci * new_pci; const uint8_t * ptr; int offset; ssize_t pdu_len; seq_num_t seq; ssize_t ttl; if (!instance) return NULL; if (!pdu_ser_is_ok(pdu)) return NULL; #ifdef CONFIG_RINA_IPCPS_CRC if (!dup_chksum_is_ok(pdu)) { LOG_ERR("Bad CRC, PDU has been corrupted"); return NULL; } /* Assuming CRC32 */ if (pdu_ser_head_shrink(pdu, sizeof(u32))) { LOG_ERR("Failed to shrink ser PDU"); return NULL; } #endif dt_cons = instance->dt_cons; ASSERT(dt_cons); tmp_buff = pdu_ser_buffer(pdu); ASSERT(tmp_buff); if (buffer_length(tmp_buff) < base_pci_size(dt_cons)) return NULL; new_pdu = pdu_create_gfp(flags); if (!new_pdu) { LOG_ERR("Failed to create new pdu"); return NULL; } new_pci = pci_create_gfp(flags); if (!new_pci) { LOG_ERR("Failed to create new pci"); pdu_destroy(new_pdu); return NULL; } ttl = 0; #ifdef CONFIG_RINA_IPCPS_TTL ttl = dup_ttl_decrement(pdu); if (ttl < 0) { LOG_ERR("Could not decrement TTL"); pci_destroy(new_pci); pdu_destroy(new_pdu); return NULL; } if (pci_ttl_set(new_pci, ttl)) { LOG_ERR("Could not set TTL"); pci_destroy(new_pci); pdu_destroy(new_pdu); return NULL; } if (pdu_ser_head_shrink(pdu, sizeof(u8))) { LOG_ERR("Failed to shrink ser PDU"); pci_destroy(new_pci); pdu_destroy(new_pdu); return NULL; } #endif ptr = (const uint8_t *) buffer_data_ro(tmp_buff); ASSERT(ptr); pdu_len = 0; if (deserialize_base_pci(instance, new_pci, &offset, ptr, &pdu_len)) { LOG_ERR("Could not deser base PCI"); pci_destroy(new_pci); pdu_destroy(new_pdu); return NULL; } switch (pci_type(new_pci)) { case PDU_TYPE_MGMT: case PDU_TYPE_DT: /* Create buffer with rest of PDU if it is a DT or MGMT PDU*/ memcpy(&seq, ptr + offset, dt_cons->seq_num_length); offset += dt_cons->seq_num_length; if (pci_sequence_number_set(new_pci, seq)) { pci_destroy(new_pci); pdu_destroy(new_pdu); return NULL; } new_buff = buffer_create_from_gfp(flags, ptr + offset, pdu_len - offset); if (!new_buff) { LOG_ERR("Could not create new_buff"); pci_destroy(new_pci); pdu_destroy(new_pdu); return NULL; } break; case PDU_TYPE_FC: if (deserialize_ctrl_seq(instance, new_pci, &offset, ptr) || deserialize_fc_pci(instance, new_pci, &offset, ptr)) { pci_destroy(new_pci); pdu_destroy(new_pdu); return NULL; } /* * FIXME: It would be better if a PDU consisted of * Base PCI + Data | Control PDU stuff * e.g. * struct pdu { * struct pci base_pci; * union { * struct buffer * data; * struct pci_ctrl * ctrl; * } * } */ new_buff = buffer_create_gfp(flags, 1); if (!new_buff) { pci_destroy(new_pci); pdu_destroy(new_pdu); return NULL; } break; case PDU_TYPE_ACK: if (deserialize_ctrl_seq(instance, new_pci, &offset, ptr) || deserialize_ack_pci(instance, new_pci, &offset, ptr)) { pci_destroy(new_pci); pdu_destroy(new_pdu); return NULL; } new_buff = buffer_create_gfp(flags, 1); if (!new_buff) { pci_destroy(new_pci); pdu_destroy(new_pdu); return NULL; } break; case PDU_TYPE_ACK_AND_FC: if (deserialize_ctrl_seq(instance, new_pci, &offset, ptr) || deserialize_ack_pci(instance, new_pci, &offset, ptr) || deserialize_fc_pci(instance, new_pci, &offset, ptr)) { pci_destroy(new_pci); pdu_destroy(new_pdu); return NULL; } new_buff = buffer_create_gfp(flags, 1); if (!new_buff) { pci_destroy(new_pci); pdu_destroy(new_pdu); return NULL; } break; case PDU_TYPE_CC: if (deserialize_ctrl_seq(instance, new_pci, &offset, ptr) || deserialize_cc_pci(instance, new_pci, &offset, ptr)) { pci_destroy(new_pci); pdu_destroy(new_pdu); return NULL; } new_buff = buffer_create_gfp(flags, 1); if (!new_buff) { pci_destroy(new_pci); pdu_destroy(new_pdu); return NULL; } break; default: LOG_ERR("Unknown PDU type %02X", pci_type(new_pci)); pci_destroy(new_pci); pdu_destroy(new_pdu); return NULL; } if (pdu_pci_set(new_pdu, new_pci)) { LOG_ERR("Failed to set PCI in PDU"); buffer_destroy(new_buff); pci_destroy(new_pci); pdu_destroy(new_pdu); return NULL; } if (pdu_buffer_set(new_pdu, new_buff)) { LOG_ERR("Failed to set buffer in PDU"); pdu_destroy(new_pdu); return NULL; } ASSERT(pdu_is_ok(new_pdu)); pdu_ser_destroy(pdu); return new_pdu; }
static int deserialize_base_pci(const struct serdes * instance, struct pci * new_pci, int * offset, const uint8_t * ptr, ssize_t * pdu_len) { int vers; address_t addr; cep_id_t cep; qos_id_t qos; pdu_type_t pdu_type; pdu_flags_t pdu_flags; struct dt_cons * dt_cons; ASSERT(instance); ASSERT(new_pci); ASSERT(ptr); dt_cons = instance->dt_cons; ASSERT(dt_cons); vers = 0; addr = 0; cep = 0; qos = 0; pdu_type = 0x00; pdu_flags = 0x0; *offset = 0; memcpy(&vers, ptr + *offset, VERSION_SIZE); *offset += VERSION_SIZE; if (vers != version) { LOG_ERR("Received an unknown version of the EFCP PDU (%d)", vers); return -1; } memcpy(&addr, ptr + *offset, dt_cons->address_length); *offset += dt_cons->address_length; if (pci_destination_set(new_pci, addr)) return -1; memcpy(&addr, ptr + *offset, dt_cons->address_length); *offset += dt_cons->address_length; if (pci_source_set(new_pci, addr)) return -1; memcpy(&qos, ptr + *offset, dt_cons->qos_id_length); *offset += dt_cons->qos_id_length; if (pci_qos_id_set(new_pci, qos)) return -1; memcpy(&cep, ptr + *offset, dt_cons->cep_id_length); *offset += dt_cons->cep_id_length; if (pci_cep_source_set(new_pci, cep)) return -1; memcpy(&cep, ptr + *offset, dt_cons->cep_id_length); *offset += dt_cons->cep_id_length; if (pci_cep_destination_set(new_pci, cep)) return -1; memcpy(&pdu_type, ptr + *offset, PDU_TYPE_SIZE); *offset += PDU_TYPE_SIZE; if (pci_type_set(new_pci, pdu_type)) return -1; memcpy(&pdu_flags, ptr + *offset, FLAGS_SIZE); *offset += FLAGS_SIZE; if (pci_flags_set(new_pci, pdu_flags)) return -1; memcpy(pdu_len, ptr + *offset, dt_cons->length_length); *offset += dt_cons->length_length; return 0; }
void rust_task_yield_fail(rust_task *task) { LOG_ERR(task, task, "task %" PRIxPTR " yielded in an atomic section", task); task->fail(); }
int main (int argc, char *argv[]) { glfs_t *fs = NULL; glfs_t *fs2 = NULL; glfs_t *fs_tmp = NULL; glfs_t *fs_tmp2 = NULL; int ret = 0, i; glfs_fd_t *fd = NULL; glfs_fd_t *fd2 = NULL; glfs_fd_t *fd_tmp = NULL; glfs_fd_t *fd_tmp2 = NULL; char readbuf[32]; char *filename = "file_tmp"; char *writebuf = NULL; char *vol_id = NULL; unsigned int cnt = 1; struct callback_arg cbk; char *logfile = NULL; char *volname = NULL; cbk.object = NULL; if (argc != 3) { fprintf (stderr, "Invalid argument\n"); exit(1); } volname = argv[1]; logfile = argv[2]; fs = glfs_new (volname); if (!fs) { fprintf (stderr, "glfs_new: returned NULL\n"); return -1; } ret = glfs_set_volfile_server (fs, "tcp", "localhost", 24007); LOG_ERR("glfs_set_volfile_server", ret); ret = glfs_set_logging (fs, logfile, 7); LOG_ERR("glfs_set_logging", ret); ret = glfs_init (fs); LOG_ERR("glfs_init", ret); fs2 = glfs_new (volname); if (!fs2) { fprintf (stderr, "glfs_new fs2: returned NULL\n"); return 1; } ret = glfs_set_volfile_server (fs2, "tcp", "localhost", 24007); LOG_ERR("glfs_set_volfile_server-fs2", ret); ret = glfs_set_logging (fs2, logfile, 7); LOG_ERR("glfs_set_logging-fs2", ret); ret = glfs_init (fs2); LOG_ERR("glfs_init-fs2", ret); fd = glfs_creat(fs, filename, O_RDWR|O_SYNC, 0644); if (fd <= 0) { ret = -1; LOG_ERR ("glfs_creat", ret); } fprintf (stderr, "glfs-create fd - %d\n", fd); fd2 = glfs_open(fs2, filename, O_SYNC|O_RDWR|O_CREAT); if (fd2 <= 0) { ret = -1; LOG_ERR ("glfs_open-fs2", ret); } fprintf (stderr, "glfs-open fd2 - %d\n", fd2); do { if (cnt%2) { fd_tmp = fd; fs_tmp = fs; fd_tmp2 = fd2; fs_tmp2 = fs2; } else { fd_tmp = fd2; fs_tmp = fs2; fd_tmp2 = fd; fs_tmp2 = fs; } /* WRITE on fd_tmp */ writebuf = malloc(10); if (writebuf) { memcpy (writebuf, "abcd", 4); ret = glfs_write (fd_tmp, writebuf, 4, 0); if (ret <= 0) { ret = -1; LOG_ERR ("glfs_write", ret); } else { fprintf (stderr, "glfs_write suceeded\n"); } free(writebuf); } else { fprintf (stderr, "Could not allocate writebuf\n"); return -1; } /* READ on fd_tmp2 */ ret = glfs_lseek (fd_tmp2, 0, SEEK_SET); LOG_ERR ("glfs_lseek", ret); ret = glfs_pread (fd_tmp2, readbuf, 4, 0, 0); if (ret <= 0) { ret = -1; LOG_ERR ("glfs_pread", ret); } else { fprintf (stderr, "glfs_read: %s\n", readbuf); } /* Open() fops seem to be not performed on server side until * there are I/Os on that fd */ if (cnt > 2) { ret = glfs_h_poll_upcall(fs_tmp, &cbk); LOG_ERR ("glfs_h_poll_upcall", ret); if (cbk.object) { fprintf (stderr, " upcall event type - %d," " flags - %d, expire_time_attr - %d\n" , cbk.reason, cbk.flags, cbk.expire_time_attr); } else { fprintf (stderr, "Dint receive upcall notify event"); ret = -1; goto err; } } sleep(5); } while (++cnt < 5); err: glfs_close(fd); LOG_ERR ("glfs_close", ret); glfs_close(fd2); LOG_ERR ("glfs_close-fd2", ret); out: if (fs) { ret = glfs_fini(fs); fprintf (stderr, "glfs_fini(fs) returned %d \n", ret); } if (fs2) { ret = glfs_fini(fs2); fprintf (stderr, "glfs_fini(fs2) returned %d \n", ret); } if (ret) exit(1); exit(0); }
int init_server_CA_certs(char ** ppc_CAcerts) { /* pointer to current CA certificate */ char * pc_CAcert; /* index of current CA certificate in ppc_CAcerts array */ int i = 0; int8_t c_ret = 0; en_gciResult_t err; /* loop over CA certificates in ppc_CAcerts (assuming it is NULL-terminated) */ while (i < SSL_SERVER_CA_CERTS_NUM && (pc_CAcert = ppc_CAcerts[i]) != NULL) { /*printf("> Initializing server CA certificate [%d] = '\033[01;32m%s\033[00;00m'\n", i, pc_CAcert);*/ /* Get pointer to a list of CA certificates */ s_sslCertList_t * ps_listHead = sslSoc_getCaCertList(&s_sslSett); /* Initialize cdb_certificate with a given pure CA Certificate */ s_cdbCert_t s_cdbCert; cdb_initCert_linear(&s_cdbCert, pc_CAcert); /* Init the pointer to the "root CA" of the selected certificate */ s_sslCert_t * ps_rootCaCert = (i == 0) ? &as_caCert[0] : &as_caCert[i - 1]; s_sslOctetStr_t so_caCert; size_t sz_bufLen; /* Try to init the CA certificate */ so_caCert.pc_data = cdb_read2buf(&s_cdbCert, &sz_bufLen); if (so_caCert.pc_data == NULL) { printf("\033[01;31mERROR: Failed to read certificate %d\033[00;00m\n", i); } else { /* Everything is ok, so assign length of successfully read cert */ so_caCert.cwt_len = sz_bufLen; /* Give pointer to a public key to generate a new one */ //OLD-CW: cw_rsa_publickey_init(&as_caCert[i].gci_caPubKey); c_ret = sslCert_init( &so_caCert, &as_caCert[i], &as_caCert[i].gci_caPubKey, (uint8_t*)&ServerCaSubject[i], SSL_SUBJECT_STORAGE_SIZE, ps_rootCaCert, NULL); /* Check here if init was OK and we've not to tried * init the Sub-Sub-Sub CA cert which must fail */ if (c_ret == E_SSL_CERT_OK) { /* Shrink the memory of the initialised public key to save memory */ //OLD-CW: cw_rsa_publickey_shrink(&as_caCert[i].gci_caPubKey); ps_listHead = sslCert_addToList(ps_listHead, &s_caCertList[i], &as_caCert[i], NULL); sslSoc_setCaCertList(&s_sslSett, ps_listHead); c_ret = 0; } else { printf("\033[01;31mERROR: Failed to import certificate %d\033[00;00m\n", i); LOG_ERR("At import of certificate %i occurred error: %s", i, sslDiag_getCertError(c_ret)); if ((i == (SSL_SERVER_CA_CERTS_NUM - 1)) && (c_ret == E_SSL_CERT_ERR_PATHLENCONSTRAINT)) { LOG_ERR("CA in the chain defined a maximal path length"); } //OLD-CW: cw_rsa_publickey_free(&as_caCert[i].gci_caPubKey); err = gciKeyDelete(&as_caCert[i].gci_caPubKey); if(err != en_gciResult_Ok) { //TODO return error state } c_ret = -1; } /* if ... else */ cdb_free(); } i++; } return c_ret; }
/** * Scan command line arguments * @param arg_count the number of arguments * @param arg_values he command line arguments * @return FALSE if exit, TRUE otherwise */ bool configfile_scan_arguments (Sint32 arg_count, char **arg_values) { Sint32 i; for (i = 1; i < arg_count; i++) { if (*arg_values[i] != '-') { continue; } /* display help */ if (!strcmp (arg_values[i], "-h") || !strcmp (arg_values[i], "--help")) { fprintf (stdout, "\noptions:\n" "-h, --help print Help (this message) and exit\n" "--version print version information and exit\n" "-x extract sprites in PNG format and exit\n" "--320 game run in a 320*200 window (slow machine)\n" "--2x scale2x\n" "--3x scale3x\n" "--4x scale4x\n" "--joyconfig x,y,f,o,s\n" " use the indicated joystick axes and buttons for the\n" " x-axis, y-axis, fire button, option button, and start button,\n" " respectively. The following argument must be 5 integers\n" " seperated by commas. The default is 0,1,0,1,2\n"); #ifdef POWERMANGA_SDL fprintf (stdout, "--window windowed mode\n"); fprintf (stdout, "--fullscreen fullscreen mode\n"); #endif fprintf (stdout, #if defined(POWERMANGA_LOG_ENABLED) "-q \n" "-v verbose mode\n" "--verbose verbose mode (more messages)\n" #endif "--nosound disable sound and musics\n" "--sound enable sound and musics\n" "--nosync disable timer\n" "--easy easy bonuses\n" "--hard hard bonuses\n" "--------------------------------------------------------------\n" "keys recognized during the game:\n" "[Ctrl] + [S] enable/disable the music\n" "[Ctrl] + [Q] finish the play current\n" "[Ctrl] + [A] about Powermanga\n" "[F10] quit Powermanga\n" "[P] enable/disable pause\n" "[Page Down] volume down\n" "[Page Up] volume up\n"); #ifdef POWERMANGA_SDL fprintf (stdout, "F switch between full screen and windowed mode\n"); #endif return FALSE; } /* print version information and exit */ if (!strcmp (arg_values[i], "--version")) { printf (POWERMANGA_VERSION); printf ("\n"); printf ("copyright (c) 1998-2015 TLK Games\n"); printf ("website: http://linux.tlk.fr/\n"); return FALSE; } /* force window mode */ if (!strcmp (arg_values[i], "--window")) { power_conf->fullscreen = FALSE; continue; } /* force fullscreen mode */ if (!strcmp (arg_values[i], "--fullscreen")) { power_conf->fullscreen = TRUE; continue; } /* resolution, low-res or high-res */ if (!strcmp (arg_values[i], "--320")) { power_conf->resolution = 320; power_conf->scale_x = 1; continue; } if (!strcmp (arg_values[i], "--640")) { power_conf->resolution = 640; power_conf->scale_x = 1; continue; } if (!strcmp (arg_values[i], "--2x")) { power_conf->scale_x = 2; power_conf->resolution = 640; continue; } if (!strcmp (arg_values[i], "--3x")) { power_conf->scale_x = 3; power_conf->resolution = 640; continue; } if (!strcmp (arg_values[i], "--4x")) { power_conf->scale_x = 4; power_conf->resolution = 640; continue; } /* Joystick configuration */ if (!strcmp (arg_values[i], "--joyconfig")) { if (sscanf (arg_values[++i], "%d,%d,%d,%d,%d", &power_conf->joy_x_axis, &power_conf->joy_y_axis, &power_conf->joy_fire, &power_conf->joy_option, &power_conf->joy_start) != 5) { LOG_ERR ("Invalid joystick configuration, expecting 5 integers seperated by commas, found %s", arg_values[i]); return FALSE; } continue; } /* enable verbose mode */ if (!strcmp (arg_values[i], "-q")) { power_conf->verbose = 0; continue; } if (!strcmp (arg_values[i], "-v")) { power_conf->verbose = 1; continue; } if (!strcmp (arg_values[i], "--verbose")) { power_conf->verbose = 2; continue; } /* enable extract sprites to png */ if (!strcmp (arg_values[i], "-x")) { power_conf->extract_to_png = TRUE; continue; } /* disable sound */ if (!strcmp (arg_values[i], "--nosound")) { power_conf->nosound = TRUE; continue; } /* disable sound */ if (!strcmp (arg_values[i], "--sound")) { power_conf->nosound = FALSE; continue; } /* disable timer */ if (!strcmp (arg_values[i], "--nosync")) { power_conf->nosync = TRUE; continue; } /* difficulty: easy or hard (normal bu default) */ if (!strcmp (arg_values[i], "--easy")) { power_conf->difficulty = 0; continue; } if (!strcmp (arg_values[i], "--hard")) { power_conf->difficulty = 2; continue; } } return TRUE; }
/***************************************************************************** VCDOpen: open VCD. read in meta-information about VCD: the number of tracks, segments, entries, size and starting information. Then set up state variables so that we read/seek starting at the location specified. On success we return VLC_SUCCESS, on memory exhausted VLC_ENOMEM, and VLC_EGENERIC for some other error. *****************************************************************************/ int VCDOpen ( vlc_object_t *p_this ) { access_t *p_access = (access_t *)p_this; vcdplayer_t *p_vcdplayer; char *psz_source; vcdinfo_itemid_t itemid; bool play_single_item = false; p_access->pf_read = NULL; p_access->pf_block = VCDReadBlock; p_access->pf_control = VCDControl; p_access->pf_seek = VCDSeek; p_access->info.i_pos = 0; p_access->info.b_eof = false; p_vcdplayer = malloc( sizeof(vcdplayer_t) ); if( p_vcdplayer == NULL ) return VLC_ENOMEM; p_vcdplayer->i_debug = var_InheritInteger( p_this, MODULE_STRING "-debug" ); p_access->p_sys = (access_sys_t *) p_vcdplayer; p_vcdplayer->size = 0; /* Set where to log errors messages from libcdio. */ p_vcd_access = p_access; cdio_log_set_handler ( cdio_log_handler ); vcd_log_set_handler ( vcd_log_handler ); psz_source = VCDParse( p_access, &itemid, &play_single_item ); if ( NULL == psz_source ) { free( p_vcdplayer ); return( VLC_EGENERIC ); } dbg_print( (INPUT_DBG_CALL|INPUT_DBG_EXT), "source: %s: mrl: %s", psz_source, p_access->psz_location ); p_vcdplayer->psz_source = strdup(psz_source); p_vcdplayer->i_blocks_per_read = var_InheritInteger( p_this, MODULE_STRING "-blocks-per-read" ); p_vcdplayer->b_track_length = var_InheritInteger( p_this, MODULE_STRING "-track-length" ); p_vcdplayer->in_still = false; p_vcdplayer->play_item.type = VCDINFO_ITEM_TYPE_NOTFOUND; p_vcdplayer->p_input = p_access->p_input; // p_vcdplayer->p_meta = vlc_meta_New(); p_vcdplayer->p_segments = NULL; p_vcdplayer->p_entries = NULL; p_vcdplayer->i_cur_title = 0; p_vcdplayer->i_cur_chapter = 0; /* set up input */ if( !(p_vcdplayer->vcd = vcd_Open( p_this, psz_source )) ) { goto err_exit; } p_vcdplayer->b_svd = vcdinfo_get_tracksSVD(p_vcdplayer->vcd); /* Get track information. */ p_vcdplayer->i_tracks = vcdinfo_get_num_tracks(p_vcdplayer->vcd); if( p_vcdplayer->i_tracks<1 || CDIO_INVALID_TRACK==p_vcdplayer->i_tracks ) { vcdinfo_close( p_vcdplayer->vcd ); LOG_ERR ("no movie tracks found" ); goto err_exit; } /* Build Navigation Title table for the tracks. */ VCDTitles( p_access ); /* Add into the above entry points as "Chapters". */ if( ! VCDEntryPoints( p_access ) ) { msg_Warn( p_access, "could not read entry points, will not use them" ); p_vcdplayer->b_valid_ep = false; } /* Initialize LID info and add that as a menu item */ if( ! VCDLIDs( p_access ) ) { msg_Warn( p_access, "could not read entry LIDs" ); } /* Do we set PBC (via LID) on? */ p_vcdplayer->i_lid = ( VCDINFO_ITEM_TYPE_LID == itemid.type && p_vcdplayer->i_lids > itemid.num ) ? itemid.num : VCDINFO_INVALID_ENTRY; /* Initialize segment information and add that a "Track". */ VCDSegments( p_access ); vcdplayer_play( p_access, itemid ); #ifdef FIXED if( play_single_item ) VCDFixupPlayList(p_access,p_vcd,psz_source,&itemid,play_single_item); #endif p_vcdplayer->p_access = p_access; free( psz_source ); return VLC_SUCCESS; err_exit: free( psz_source ); free( p_vcdplayer->psz_source ); free( p_vcdplayer ); return VLC_EGENERIC; }
static int usb_dc_stm32_clock_enable(void) { struct device *clk = device_get_binding(STM32_CLOCK_CONTROL_NAME); struct stm32_pclken pclken = { #ifdef DT_USB_HS_BASE_ADDRESS .bus = STM32_CLOCK_BUS_AHB1, .enr = LL_AHB1_GRP1_PERIPH_OTGHS #else /* DT_USB_HS_BASE_ADDRESS */ #ifdef USB .bus = STM32_CLOCK_BUS_APB1, .enr = LL_APB1_GRP1_PERIPH_USB, #else /* USB_OTG_FS */ #ifdef CONFIG_SOC_SERIES_STM32F1X .bus = STM32_CLOCK_BUS_AHB1, .enr = LL_AHB1_GRP1_PERIPH_OTGFS, #else .bus = STM32_CLOCK_BUS_AHB2, .enr = LL_AHB2_GRP1_PERIPH_OTGFS, #endif /* CONFIG_SOC_SERIES_STM32F1X */ #endif /* USB */ #endif /* DT_USB_HS_BASE_ADDRESS */ }; /* * Some SoCs in STM32F0/L0/L4 series disable USB clock by * default. We force USB clock source to MSI or PLL clock for this * SoCs. However, if these parts have an HSI48 clock, use * that instead. Example reference manual RM0360 for * STM32F030x4/x6/x8/xC and STM32F070x6/xB. */ #if defined(RCC_HSI48_SUPPORT) /* * In STM32L0 series, HSI48 requires VREFINT and its buffer * with 48 MHz RC to be enabled. * See ENREF_HSI48 in referenc maual RM0367 section10.2.3: * "Reference control and status register (SYSCFG_CFGR3)" */ #ifdef CONFIG_SOC_SERIES_STM32L0X if (LL_APB2_GRP1_IsEnabledClock(LL_APB2_GRP1_PERIPH_SYSCFG)) { LL_SYSCFG_VREFINT_EnableHSI48(); } else { LOG_ERR("System Configuration Controller clock is " "disabled. Unable to enable VREFINT which " "is required by HSI48."); } #endif /* CONFIG_SOC_SERIES_STM32L0X */ LL_RCC_HSI48_Enable(); while (!LL_RCC_HSI48_IsReady()) { /* Wait for HSI48 to become ready */ } LL_RCC_SetUSBClockSource(LL_RCC_USB_CLKSOURCE_HSI48); #elif defined(LL_RCC_USB_CLKSOURCE_NONE) /* When MSI is configured in PLL mode with a 32.768 kHz clock source, * the MSI frequency can be automatically trimmed by hardware to reach * better than ±0.25% accuracy. In this mode the MSI can feed the USB * device. For now, we only use MSI for USB if not already used as * system clock source. */ #if defined(CONFIG_CLOCK_STM32_MSI_PLL_MODE) && !defined(CONFIG_CLOCK_STM32_SYSCLK_SRC_MSI) LL_RCC_MSI_Enable(); while (!LL_RCC_MSI_IsReady()) { /* Wait for MSI to become ready */ } /* Force 48 MHz mode */ LL_RCC_MSI_EnableRangeSelection(); LL_RCC_MSI_SetRange(LL_RCC_MSIRANGE_11); LL_RCC_SetUSBClockSource(LL_RCC_USB_CLKSOURCE_MSI); #else if (LL_RCC_PLL_IsReady()) { LL_RCC_SetUSBClockSource(LL_RCC_USB_CLKSOURCE_PLL); } else { LOG_ERR("Unable to set USB clock source to PLL."); } #endif /* CONFIG_CLOCK_STM32_MSI_PLL_MODE && !CONFIG_CLOCK_STM32_SYSCLK_SRC_MSI */ #endif /* RCC_HSI48_SUPPORT / LL_RCC_USB_CLKSOURCE_NONE */ if (clock_control_on(clk, (clock_control_subsys_t *)&pclken) != 0) { LOG_ERR("Unable to enable USB clock"); return -EIO; } #ifdef DT_USB_HS_BASE_ADDRESS #ifdef DT_COMPAT_ST_STM32_USBPHYC LL_AHB1_GRP1_EnableClock(LL_AHB1_GRP1_PERIPH_OTGHSULPI); LL_APB2_GRP1_EnableClock(LL_APB2_GRP1_PERIPH_OTGPHYC); #else /* Disable ULPI interface (for external high-speed PHY) clock */ LL_AHB1_GRP1_DisableClock(LL_AHB1_GRP1_PERIPH_OTGHSULPI); LL_AHB1_GRP1_DisableClockLowPower(LL_AHB1_GRP1_PERIPH_OTGHSULPI); #endif /* DT_COMPAT_ST_STM32_USBPHYC */ #endif /* DT_USB_HS_BASE_ADDRESS */ return 0; } #if defined(USB_OTG_FS) || defined(USB_OTG_HS) static u32_t usb_dc_stm32_get_maximum_speed(void) { /* * If max-speed is not passed via DT, set it to USB controller's * maximum hardware capability. */ #if defined(DT_COMPAT_ST_STM32_USBPHYC) && defined(DT_USB_HS_BASE_ADDRESS) u32_t speed = USB_OTG_SPEED_HIGH; #else u32_t speed = USB_OTG_SPEED_FULL; #endif /* DT_COMPAT_ST_STM32_USBPHYC && DT_USB_HS_BASE_ADDRESS */ #ifdef DT_USB_MAXIMUM_SPEED if (!strncmp(DT_USB_MAXIMUM_SPEED, "high-speed", 10)) { speed = USB_OTG_SPEED_HIGH; } else if (!strncmp(DT_USB_MAXIMUM_SPEED, "full-speed", 10)) { #if defined(DT_COMPAT_ST_STM32_USBPHYC) && defined(DT_USB_HS_BASE_ADDRESS) speed = USB_OTG_SPEED_HIGH_IN_FULL; #else speed = USB_OTG_SPEED_FULL; #endif /* DT_COMPAT_ST_STM32_USBPHYC && DT_USB_HS_BASE_ADDRESS */ } else if (!strncmp(DT_USB_MAXIMUM_SPEED, "low-speed", 9)) { speed = USB_OTG_SPEED_LOW; } else { LOG_DBG("Unsupported maximum speed defined in device tree. " "USB controller will default to its maximum HW " "capability"); } #endif /* DT_USB_MAXIMUM_SPEED */ return speed; }
static int init_mem(unsigned nb_mbuf) { int socketid; unsigned lcore_id; char s[64]; for (lcore_id = 0; lcore_id < RTE_MAX_LCORE; lcore_id++) { if (rte_lcore_is_enabled(lcore_id) == 0) continue; if (sk.numa_on) socketid = rte_lcore_to_socket_id(lcore_id); else socketid = 0; if (socketid >= NB_SOCKETS) { rte_exit(EXIT_FAILURE, "Socket %d of lcore %u is out of range %d\n", socketid, lcore_id, NB_SOCKETS); } if (pktmbuf_pool[socketid] == NULL) { snprintf(s, sizeof(s), "mbuf_pool_%d", socketid); pktmbuf_pool[socketid] = rte_pktmbuf_pool_create(s, nb_mbuf, MEMPOOL_CACHE_SIZE, 0, RTE_MBUF_DEFAULT_BUF_SIZE, socketid); if (pktmbuf_pool[socketid] == NULL) rte_exit(EXIT_FAILURE, "Cannot init mbuf pool on socket %d\n", socketid); else LOG_INFO("Allocated mbuf pool on socket %d.", socketid); } #ifdef IP_FRAG struct rte_mempool *mp; if (socket_direct_pool[socketid] == NULL) { LOG_INFO("Creating direct mempool on socket %i\n", socketid); snprintf(s, sizeof(s), "pool_direct_%i", socketid); mp = rte_pktmbuf_pool_create(s, IP_FRAG_NB_MBUF, 32, 0, RTE_MBUF_DEFAULT_BUF_SIZE, socketid); if (mp == NULL) { LOG_ERR("Cannot create direct mempool\n"); return -1; } socket_direct_pool[socketid] = mp; } if (socket_indirect_pool[socketid] == NULL) { LOG_INFO("Creating indirect mempool on socket %i\n", socketid); snprintf(s, sizeof(s), "pool_indirect_%i", socketid); mp = rte_pktmbuf_pool_create(s, IP_FRAG_NB_MBUF, 32, 0, 0, socketid); if (mp == NULL) { LOG_ERR("Cannot create indirect mempool\n"); return -1; } socket_indirect_pool[socketid] = mp; } #endif } return 0; }
static int usb_dc_stm32_init(void) { HAL_StatusTypeDef status; unsigned int i; #ifdef USB usb_dc_stm32_state.pcd.Instance = USB; usb_dc_stm32_state.pcd.Init.speed = PCD_SPEED_FULL; usb_dc_stm32_state.pcd.Init.dev_endpoints = DT_USB_NUM_BIDIR_ENDPOINTS; usb_dc_stm32_state.pcd.Init.phy_itface = PCD_PHY_EMBEDDED; usb_dc_stm32_state.pcd.Init.ep0_mps = PCD_EP0MPS_64; usb_dc_stm32_state.pcd.Init.low_power_enable = 0; #else /* USB_OTG_FS || USB_OTG_HS */ #ifdef DT_USB_HS_BASE_ADDRESS usb_dc_stm32_state.pcd.Instance = USB_OTG_HS; #else usb_dc_stm32_state.pcd.Instance = USB_OTG_FS; #endif usb_dc_stm32_state.pcd.Init.dev_endpoints = DT_USB_NUM_BIDIR_ENDPOINTS; usb_dc_stm32_state.pcd.Init.speed = usb_dc_stm32_get_maximum_speed(); #if defined(DT_COMPAT_ST_STM32_USBPHYC) && defined(DT_USB_HS_BASE_ADDRESS) usb_dc_stm32_state.pcd.Init.phy_itface = USB_OTG_HS_EMBEDDED_PHY; #else usb_dc_stm32_state.pcd.Init.phy_itface = PCD_PHY_EMBEDDED; #endif /* DT_COMPAT_ST_STM32_USBPHYC */ usb_dc_stm32_state.pcd.Init.ep0_mps = USB_OTG_MAX_EP0_SIZE; usb_dc_stm32_state.pcd.Init.vbus_sensing_enable = DISABLE; #ifndef CONFIG_SOC_SERIES_STM32F1X usb_dc_stm32_state.pcd.Init.dma_enable = DISABLE; #endif #endif /* USB */ #ifdef CONFIG_USB_DEVICE_SOF usb_dc_stm32_state.pcd.Init.Sof_enable = 1; #endif /* CONFIG_USB_DEVICE_SOF */ LOG_DBG("HAL_PCD_Init"); status = HAL_PCD_Init(&usb_dc_stm32_state.pcd); if (status != HAL_OK) { LOG_ERR("PCD_Init failed, %d", (int)status); return -EIO; } LOG_DBG("HAL_PCD_Start"); status = HAL_PCD_Start(&usb_dc_stm32_state.pcd); if (status != HAL_OK) { LOG_ERR("PCD_Start failed, %d", (int)status); return -EIO; } usb_dc_stm32_state.out_ep_state[EP0_IDX].ep_mps = EP0_MPS; usb_dc_stm32_state.out_ep_state[EP0_IDX].ep_type = EP_TYPE_CTRL; usb_dc_stm32_state.in_ep_state[EP0_IDX].ep_mps = EP0_MPS; usb_dc_stm32_state.in_ep_state[EP0_IDX].ep_type = EP_TYPE_CTRL; #ifdef USB /* Start PMA configuration for the endpoints after the BTABLE. */ usb_dc_stm32_state.pma_offset = USB_BTABLE_SIZE; for (i = 0U; i < DT_USB_NUM_BIDIR_ENDPOINTS; i++) { k_sem_init(&usb_dc_stm32_state.in_ep_state[i].write_sem, 1, 1); } #else /* USB_OTG_FS */ /* TODO: make this dynamic (depending usage) */ HAL_PCDEx_SetRxFiFo(&usb_dc_stm32_state.pcd, FIFO_EP_WORDS); for (i = 0U; i < DT_USB_NUM_BIDIR_ENDPOINTS; i++) { HAL_PCDEx_SetTxFiFo(&usb_dc_stm32_state.pcd, i, FIFO_EP_WORDS); k_sem_init(&usb_dc_stm32_state.in_ep_state[i].write_sem, 1, 1); } #endif /* USB */ IRQ_CONNECT(DT_USB_IRQ, DT_USB_IRQ_PRI, usb_dc_stm32_isr, 0, 0); irq_enable(DT_USB_IRQ); return 0; }
static int ctrl_handle_mod_service_msg(struct ctrlmsg *cm, int peer) { struct ctrlmsg_service *cmr = (struct ctrlmsg_service *)cm; unsigned int num_res = CTRLMSG_SERVICE_NUM(cmr); unsigned int i, index = 0; int err = 0; if (num_res < 2 || num_res % 2 != 0) { LOG_DBG("Not an even number of service infos\n"); return 0; } LOG_DBG("modifying %u services\n", num_res / 2); for (i = 0; i < num_res; i += 2) { struct net_device *dev; struct service_info *entry_old = &cmr->service[i]; struct service_info *entry_new = &cmr->service[i+1]; unsigned short prefix_bits = SERVICE_ID_MAX_PREFIX_BITS; if (entry_old->srvid_prefix_bits > 0) prefix_bits = entry_old->srvid_prefix_bits; #if defined(ENABLE_DEBUG) { char buf[18]; LOG_DBG("Modifying: %s flags(%i) bits(%i) %s\n", service_id_to_str(&entry_old->srvid), entry_old->srvid_flags, prefix_bits, inet_ntop(AF_INET, &entry_old->address, buf, 18)); } #endif dev = resolve_dev(entry_old); if (!dev) continue; err = service_modify(&entry_old->srvid, prefix_bits, SERVICE_RULE_FORWARD, entry_old->srvid_flags, entry_new->priority, entry_new->weight, &entry_old->address, sizeof(entry_old->address), &entry_new->address, sizeof(entry_new->address), make_target(dev)); if (err > 0) { if (index < i) { /* copy it over */ memcpy(&cmr->service[index], entry_new, sizeof(*entry_new)); } index++; } else { LOG_ERR("Could not modify service %s: %i\n", service_id_to_str(&entry_old->srvid), err); } dev_put(dev); } if (index == 0) { cm->retval = CTRLMSG_RETVAL_NOENTRY; } else { cm->retval = CTRLMSG_RETVAL_OK; cm->len = CTRLMSG_SERVICE_NUM_LEN(index); } ctrl_sendmsg(cm, peer, GFP_KERNEL); return 0; }
int usb_dc_detach(void) { LOG_ERR("Not implemented"); return 0; }
int main (int argc, char *argv[]) { glfs_t *fs = NULL; glfs_t *fs2 = NULL; int ret = 0, i; glfs_fd_t *fd = NULL; char *filename = "/a1"; char *filename2 = "/a2"; struct stat sb = {0, }; char *logfile = NULL; char *volname = NULL; char *hostname = NULL; int cnt = 1; int upcall_received = 0; struct glfs_upcall *cbk = NULL; struct glfs_object *root = NULL, *leaf = NULL; unsigned char globjhdl[GFAPI_HANDLE_LENGTH]; unsigned char globjhdl2[GFAPI_HANDLE_LENGTH]; fprintf (stderr, "Starting libgfapi_fini\n"); if (argc != 4) { fprintf (stderr, "Invalid argument\n"); exit(1); } hostname = argv[1]; volname = argv[2]; logfile = argv[3]; fs = glfs_new (volname); if (!fs) { fprintf (stderr, "glfs_new: returned NULL\n"); return 1; } ret = glfs_set_volfile_server (fs, "tcp", hostname, 24007); LOG_ERR("glfs_set_volfile_server", ret); ret = glfs_set_logging (fs, logfile, 7); LOG_ERR("glfs_set_logging", ret); ret = glfs_init (fs); LOG_ERR("glfs_init", ret); /* This does not block, but enables caching of events. Real * applications like NFS-Ganesha run this in a thread before activity * on the fs (through this instance) happens. */ ret = glfs_h_poll_upcall(fs, &cbk); LOG_ERR ("glfs_h_poll_upcall", ret); fs2 = glfs_new (volname); if (!fs) { fprintf (stderr, "glfs_new: returned NULL\n"); return 1; } ret = glfs_set_volfile_server (fs2, "tcp", hostname, 24007); LOG_ERR("glfs_set_volfile_server", ret); ret = glfs_set_logging (fs2, logfile, 7); LOG_ERR("glfs_set_logging", ret); ret = glfs_init (fs2); LOG_ERR("glfs_init", ret); sleep (2); root = glfs_h_lookupat (fs, NULL, "/", &sb, 0); if (!root) { ret = -1; LOG_ERR ("glfs_h_lookupat root", ret); } leaf = glfs_h_lookupat (fs, root, filename, &sb, 0); if (!leaf) { ret = -1; LOG_IF_NO_ERR ("glfs_h_lookupat leaf", ret); } root = glfs_h_lookupat (fs2, NULL, "/", &sb, 0); if (!root) { ret = -1; LOG_ERR ("glfs_h_lookupat root", ret); } leaf = glfs_h_creat (fs2, root, filename, O_RDWR, 0644, &sb); if (!leaf) { ret = -1; LOG_ERR ("glfs_h_lookupat leaf", ret); } fprintf (stderr, "glfs_h_create leaf - %p\n", leaf); while (cnt++ < 5 && !upcall_received) { enum glfs_upcall_reason reason = 0; struct glfs_upcall_inode *in_arg = NULL; ret = glfs_h_poll_upcall(fs, &cbk); LOG_ERR ("glfs_h_poll_upcall", ret); if (ret) goto retry; reason = glfs_upcall_get_reason (cbk); fprintf (stderr, "Upcall received(%d)\n", reason); if (reason == GLFS_UPCALL_INODE_INVALIDATE) { struct glfs_object *object = NULL; in_arg = glfs_upcall_get_event (cbk); object = glfs_upcall_inode_get_object (in_arg); ret = glfs_h_extract_handle (root, globjhdl+GLAPI_UUID_LENGTH, GFAPI_HANDLE_LENGTH); LOG_ERR("glfs_h_extract_handle", (ret != 16)); ret = glfs_h_extract_handle (object, globjhdl2+GLAPI_UUID_LENGTH, GFAPI_HANDLE_LENGTH); LOG_ERR("glfs_h_extract_handle", (ret != 16)); if (memcmp (globjhdl+GLAPI_UUID_LENGTH, globjhdl2+GLAPI_UUID_LENGTH, 16)) { fprintf (stderr, "Error: gfid mismatch\n"); exit (1); } upcall_received = 1; } retry: if (!upcall_received) sleep (1); /* glfs_h_poll_upcall() does not block */ if (!ret) { glfs_free (cbk); cbk = NULL; } } if (!upcall_received) { fprintf (stderr, "Error: Upcall not received\n"); exit (1); } ret = glfs_fini(fs); LOG_ERR("glfs_fini", ret); fprintf (stderr, "End of libgfapi_fini\n"); exit(0); }
int usb_dc_reset(void) { LOG_ERR("Not implemented"); return 0; }
/* ------------------------------------------------------------------------------ */ static long SYSRAM_Ioctl(struct file *pFile, unsigned int Cmd, unsigned long Param) { MINT32 Ret = 0; MUINT32 Sec = 0, USec = 0; MUINT64 Time64 = 0; SYSRAM_PROC_STRUCT *pProc = (SYSRAM_PROC_STRUCT *) pFile->private_data; SYSRAM_ALLOC_STRUCT Alloc; SYSRAM_USER_ENUM User; /* */ SYSRAM_GetTime(&Time64, &Sec, &USec); /* LOG_MSG("Cur:Name(%s),pid(%d),tgid(%d),Time(%ld.%06ld)", current->comm, current->pid, current->tgid, Sec, USec); */ if (pFile->private_data == NULL) { LOG_WRN("private_data is NULL."); Ret = -EFAULT; goto EXIT; } /* */ switch (Cmd) { case SYSRAM_ALLOC: { if (copy_from_user(&Alloc, (void *)Param, sizeof(SYSRAM_ALLOC_STRUCT)) == 0) { if (SYSRAM_IsBadOwner(Alloc.User)) { LOG_ERR("User(%d) out of range(%d)", Alloc.User, SYSRAM_USER_AMOUNT); Ret = -EFAULT; goto EXIT; } /* */ Alloc.Addr = SYSRAM_IOC_Alloc(Alloc.User, Alloc.Size, Alloc.Alignment, Alloc.TimeoutMS); if (Alloc.Addr != 0) { SYSRAM_SpinLock(); pProc->Table |= (1 << Alloc.User); if (pProc->Tgid == 0) { pProc->Pid = current->pid; pProc->Tgid = current->tgid; strcpy(pProc->ProcName, current->comm); SYSRAM_SpinUnlock(); } else { SYSRAM_SpinUnlock(); /**/ if (pProc->Tgid != current->tgid) { LOG_ERR("Tgid is inconsistent"); Ret = -EFAULT; } } } else { LOG_MSG("[christ test] SYSRAM_ALLOC E.6 "); Ret = -EFAULT; } /* */ if (copy_to_user ((void *)Param, &Alloc, sizeof(SYSRAM_ALLOC_STRUCT))) { LOG_MSG("[christ test] SYSRAM_ALLOC E.7 "); LOG_ERR("copy to user failed"); Ret = -EFAULT; } } else { LOG_ERR("copy_from_user fail"); Ret = -EFAULT; } break; } /* */ case SYSRAM_FREE: { if (copy_from_user(&User, (void *)Param, sizeof(SYSRAM_USER_ENUM)) == 0) { if (SYSRAM_IsBadOwner(User)) { LOG_ERR("User(%d) out of range(%d)", User, SYSRAM_USER_AMOUNT); Ret = -EFAULT; goto EXIT; } /* */ SYSRAM_SpinLock(); if ((pProc->Table) & (1 << User)) { SYSRAM_SpinUnlock(); SYSRAM_IOC_Free(User); SYSRAM_SpinLock(); /* */ pProc->Table &= (~(1 << User)); if (pProc->Table == 0) { pProc->Pid = 0; pProc->Tgid = 0; strcpy(pProc->ProcName, SYSRAM_PROC_NAME); } SYSRAM_SpinUnlock(); } else { SYSRAM_SpinUnlock(); LOG_WRN("Freeing unallocated buffer user(%d)", User); Ret = -EFAULT; } } else { LOG_ERR("copy_from_user fail"); Ret = -EFAULT; } break; } case SYSRAM_DUMP: { SYSRAM_DumpLayout(); break; } default: { LOG_WRN("No such command"); Ret = -EINVAL; break; } } /* */ EXIT: if (Ret != 0) { LOG_ERR("Fail"); LOG_ERR("Cur:Name(%s),pid(%d),tgid(%d),Time(%ld.%06ld)", current->comm, current->pid, current->tgid, Sec, USec); if (pFile->private_data != NULL) { LOG_ERR("Proc:Name(%s),pid(%d),tgid(%d),Table(0x%08lX),Time(%ld.%06ld)", pProc->ProcName, pProc->Pid, pProc->Tgid, pProc->Table, Sec, USec); } } /* */ return Ret; }
void rust_task::new_stack(size_t requested_sz) { LOG(this, mem, "creating new stack for task %" PRIxPTR, this); if (stk) { ::check_stack_canary(stk); } // The minimum stack size, in bytes, of a Rust stack, excluding red zone size_t min_sz = sched_loop->min_stack_size; // Try to reuse an existing stack segment while (stk != NULL && stk->next != NULL) { size_t next_sz = user_stack_size(stk->next); if (min_sz <= next_sz && requested_sz <= next_sz) { LOG(this, mem, "reusing existing stack"); stk = stk->next; return; } else { LOG(this, mem, "existing stack is not big enough"); stk_seg *new_next = stk->next->next; free_stack(stk->next); stk->next = new_next; if (new_next) { new_next->prev = stk; } } } // The size of the current stack segment, excluding red zone size_t current_sz = 0; if (stk != NULL) { current_sz = user_stack_size(stk); } // The calculated size of the new stack, excluding red zone size_t rust_stk_sz = get_next_stack_size(min_sz, current_sz, requested_sz); size_t max_stack = kernel->env->max_stack_size; size_t used_stack = total_stack_sz + rust_stk_sz; // Don't allow stacks to grow forever. During unwinding we have to allow // for more stack than normal in order to allow destructors room to run, // arbitrarily selected as 2x the maximum stack size. if (!unwinding && used_stack > max_stack) { LOG_ERR(this, task, "task %" PRIxPTR " ran out of stack", this); fail(); } else if (unwinding && used_stack > max_stack * 2) { LOG_ERR(this, task, "task %" PRIxPTR " ran out of stack during unwinding", this); fail(); } size_t sz = rust_stk_sz + RED_ZONE_SIZE; stk_seg *new_stk = create_stack(&local_region, sz); LOGPTR(sched_loop, "new stk", (uintptr_t)new_stk); new_stk->task = this; new_stk->next = NULL; new_stk->prev = stk; if (stk) { stk->next = new_stk; } LOGPTR(sched_loop, "stk end", new_stk->end); stk = new_stk; total_stack_sz += user_stack_size(new_stk); }
static size_t lpc2_flash_writeDirect(struct KBlock *blk, block_idx_t idx, const void *_buf, size_t offset, size_t size) { ASSERT(offset == 0); ASSERT(FLASH_PAGE_SIZE_BYTES == size); Flash *fls = FLASH_CAST(blk); if (!(fls->blk.priv.flags & KB_WRITE_ONCE)) ASSERT(sector_size(idx) <= FLASH_PAGE_SIZE_BYTES); const uint8_t *buf = (const uint8_t *)_buf; cpu_flags_t flags; //Compute page address of current page. uint32_t addr = idx * blk->blk_size; uint32_t sector = addr_to_sector(addr); // Compute the first page index in the sector to manage the status int idx_sector = sector_addr(sector) / blk->blk_size; LOG_INFO("Writing page[%ld]sector[%ld]idx[%d]\n", idx, sector, idx_sector); IRQ_SAVE_DISABLE(flags); IapCmd cmd; IapRes res; cmd.cmd = PREPARE_SECTOR_FOR_WRITE; cmd.param[0] = cmd.param[1] = sector; iap(&cmd, &res); if (res.status != CMD_SUCCESS) goto flash_error; if ((fls->blk.priv.flags & KB_WRITE_ONCE) && bitarray_isRangeFull(&lpc2_bitx, idx_sector, erase_group[sector])) { kputs("blocchi pieni\n"); ASSERT(0); goto flash_error; } bool erase = false; if ((fls->blk.priv.flags & KB_WRITE_ONCE) && bitarray_isRangeEmpty(&lpc2_bitx, idx_sector, erase_group[sector])) erase = true; if (!(fls->blk.priv.flags & KB_WRITE_ONCE)) erase = true; if (erase) { cmd.cmd = ERASE_SECTOR; cmd.param[0] = cmd.param[1] = sector; cmd.param[2] = CPU_FREQ / 1000; iap(&cmd, &res); if (res.status != CMD_SUCCESS) goto flash_error; } LOG_INFO("Writing page [%ld], addr [%ld] in sector[%ld]\n", idx, addr, sector); cmd.cmd = PREPARE_SECTOR_FOR_WRITE; cmd.param[0] = cmd.param[1] = sector; iap(&cmd, &res); if (res.status != CMD_SUCCESS) goto flash_error; if (fls->blk.priv.flags & KB_WRITE_ONCE) { if (bitarray_test(&lpc2_bitx, idx)) { ASSERT(0); goto flash_error; } else bitarray_set(&lpc2_bitx, idx); } cmd.cmd = COPY_RAM_TO_FLASH; cmd.param[0] = addr; cmd.param[1] = (uint32_t)buf; cmd.param[2] = FLASH_PAGE_SIZE_BYTES; cmd.param[3] = CPU_FREQ / 1000; iap(&cmd, &res); if (res.status != CMD_SUCCESS) goto flash_error; IRQ_RESTORE(flags); LOG_INFO("Done\n"); return blk->blk_size; flash_error: LOG_ERR("%ld\n", res.status); fls->hw->status |= FLASH_WR_ERR; return 0; }
/*=================================================================================================*/ E_SERVER_FSM_RESULT ssl_server_entry(SSL_SERVER_PARS parameters) { /* server parameters */ uint8_t echo = parameters.echo; char * pc_filename = parameters.pc_filename; char * pc_ciphersuites = parameters.pc_ciphersuites; uint16_t u_port = parameters.u_port; e_sslVer_t versmin = parameters.versmin; e_sslVer_t versmax = parameters.versmax; char * key = parameters.key; e_sslKeyType_t keyType = parameters.keyType; char * keyParameters = parameters.keyParameters; char ** certs = parameters.ppc_certs; char ** CAcerts = parameters.ppc_CAcerts; e_sslAuthLevel_t authlevel = parameters.authlevel; char c_filebuf[SSL_WRITE_BLOCK_LEN]; size_t n; char c_mode = 1; en_gciResult_t err; /* Check the state of the server */ switch (i_state) { case SSL_SERVER_INIT: /*============================================================================*/ /* * General SSL Initialisation */ /*============================================================================*/ /* Initialises the SSL module */ SSL_init(); /* Initialises the crypto */ //TODO sw - where to become the user name + password ?? err = gciInit(NULL, 0, NULL, 0); //OLD-CW: cw_crypto_init(); // { // /* // * Use some "random" bytes to init the PRNG // */ // uint8_t c_rand[] = { 0x42, 0x72, 0x75, 0x63, 0x65, 0x20, 0x53, 0x63, 0x68, //TODO sw - this step in gci_init // 0x6E, 0x65, 0x69, 0x65, 0x72, 0x21, 0x0D, 0x0A, 0x00 }; // cw_prng_init(c_rand, sizeof(c_rand)); // } /* * Initialisation of keymanager for DHE and DHE private key generation */ km_dhe_init(); /*============================================================================*/ /* * Initialization of the SSL settings for the demonstration SSL context */ /*============================================================================*/ /* Initialises the SSL context */ sslSoc_initSett(&s_sslSett, keyType); /* * Init the time-function pointer implicit to NULL, this will disable * checking of the validity of the used certificates * (To enable 'getCurrentTime' function should be used) */ sslSoc_setTimeFunc(&s_sslSett, NULL); /* Setting up the SSL version */ sslSoc_setVer(&s_sslSett, versmin, versmax); /* Setting up the SSL timeout value */ sslSoc_setSessTimeout(&s_sslSett, 600); /* Setting up the SSL authentification behavior */ sslSoc_setAuthLvl(&s_sslSett, authlevel); /* Setting up read and write fonctions */ sslSoc_setReadWrite(&s_sslSett, sslTarget_read, sslTarget_write); /* Initialize server CA certificates */ if (CAcerts != NULL) { init_server_CA_certs(CAcerts); } /* ===== Initialize Server Certificates and private key ===== */ s_cdbCert_t cdb_tmp; s_sslCertList_t * list_head = sslSoc_getCertChainList(&s_sslSett); if (certs != NULL) { int i = 0; while (certs[i] != NULL) { /* printf("certs[%i] = '%s'\n", i, certs[i]); */ cdb_initCert_linear(&server_cdb_certs[i], certs[i]); list_head = sslCert_addToList(list_head, &server_cert_list[i], NULL, &server_cdb_certs[i]); i++; } } else { /* use static pre-defined certificates if * no external certificate has been provided */ /* int i; for (i = 0; i < SSL_SERVERCERTS_NUM; ++i) { cdb_initCert_linear(&server_cdb_certs[i], server_certificates_[i]); list_head = SSL_cert_list_add(list_head, &server_cert_list[i], NULL, &server_cdb_certs[i]); } */ } sslSoc_setCertChainList (&s_sslSett, list_head); if (key != NULL) { cdb_initCert_linear(&cdb_tmp, key); } else { /*cdb_initCert_linear(&cdb_tmp, ServerPrivateKey);*/ } switch(keyType) { case E_SSL_KEY_EC: if (sslSoc_setECCPrivKey(&s_sslSett, &cdb_tmp) != E_SSL_OK) { printf(DBG_STRING "Import of ECC private key failed", __FILE__, __LINE__); return (E_SERVER_FSM_ERROR); } /* if */ break; case E_SSL_KEY_RSA: if (sslSoc_setRsaPrivKey(&s_sslSett, &cdb_tmp) != E_SSL_OK) { printf(DBG_STRING "Import of RSA private key failed", __FILE__, __LINE__); return (E_SERVER_FSM_ERROR); } /* if */ break; default: return (E_SERVER_FSM_ERROR); break; } /* switch */ case SSL_SERVER_REINIT: /*============================================================================*/ /* * Initialize socket specific features */ /*============================================================================*/ /* Creates a socket */ #ifdef _WIN32 if((srv_socdesc = socket(AF_INET , SOCK_STREAM , 0 )) == INVALID_SOCKET) { printf("Could not create socket : %s\n" , WSAGetLastError()); WSACleanup(); return (E_SERVER_FSM_ERROR); } #elif __linux if((srv_socdesc = socket(AF_INET , SOCK_STREAM , 0 )) < 0) { printf("Could not create socket : %s\n" , strerror(errno)); return (E_SERVER_FSM_ERROR); } #endif setsockopt(srv_socdesc, SOL_SOCKET, SO_REUSEADDR, &c_mode, sizeof(int)); printf("\n\rSocket created.\n"); /* Binding */ server.sin_family = AF_INET; server.sin_addr.s_addr = INADDR_ANY; server.sin_port = htons(u_port); #ifdef _WIN32 if( bind(srv_socdesc ,(struct sockaddr *)&server , sizeof(server)) == INVALID_SOCKET) { printf("Bind failed with error code : %s\n" , WSAGetLastError()); WSACleanup(); return (E_SERVER_FSM_ERROR); } #elif __linux if( bind(srv_socdesc ,(struct sockaddr *)&server , sizeof(server)) < 0) { printf("Bind failed with error code : %s\n" , strerror(errno)); return (E_SERVER_FSM_ERROR); } #endif puts("Bind done"); /* Listening */ listen(srv_socdesc , 3); puts("Waiting for incoming connections..."); i_state = SSL_SERVER_LISTEN; break; /* SSL_SERVER_INIT */ case SSL_SERVER_LISTEN: i_addr_len = sizeof(struct sockaddr_in); cli_socdesc = accept(srv_socdesc , (struct sockaddr *)&client, &i_addr_len); if (cli_socdesc == INVALID_SOCKET) { break; } /* Nonblocking mode */ #ifdef _WIN32 ioctlsocket(cli_socdesc, FIONBIO, (u_long *)&c_mode); #elif __linux fcntl(cli_socdesc, F_SETFL, O_NONBLOCK); #endif printf("\n\rConnection accepted\n"); /* Checks if a SSL context is available */ if ((ps_sslCtx = sslSoc_new ( &s_sslSett )) == NULL) { /* Not available */ i_state = SSL_SERVER_CLOSE_ERR; } else { /* Available */ sslSoc_setCtxFd(ps_sslCtx, cli_socdesc); /* set supported ciphersuites if list is provided */ if (strlen(pc_ciphersuites) > 0) { sslSoc_setCtxCipList(ps_sslCtx, pc_ciphersuites); } int i=0; switch(keyType) { case E_SSL_KEY_EC: //loop all cipher suites provided //Remove all non-ECDSA cipher suites, as certificate cannot handle non-ECDSA for(i=0; i<SSL_CIPSPEC_COUNT; i++) { if( //remove every ECDHE curve ps_sslCtx->s_sslGut.ae_cipSpecs[i] != TLS_ECDHE_ECDSA_WITH_3DES_EDE_CBC_SHA && ps_sslCtx->s_sslGut.ae_cipSpecs[i] != TLS_ECDHE_ECDSA_WITH_AES_128_CBC_SHA && ps_sslCtx->s_sslGut.ae_cipSpecs[i] != TLS_ECDHE_ECDSA_WITH_AES_256_CBC_SHA ) { ps_sslCtx->s_sslGut.ae_cipSpecs[i] = TLS_NULL_WITH_NULL_NULL; } } break; case E_SSL_KEY_RSA: case E_SSL_KEY_UNDEFINED: //vpy: should be handled properly //Remove all ECDSA cipher suites, as certificate cannot handle ECDSA //loop all cipher suites provided for(i=0; i<SSL_CIPSPEC_COUNT; i++) { if( //remove every ECDHE curve ps_sslCtx->s_sslGut.ae_cipSpecs[i] == TLS_ECDHE_ECDSA_WITH_3DES_EDE_CBC_SHA || ps_sslCtx->s_sslGut.ae_cipSpecs[i] == TLS_ECDHE_ECDSA_WITH_AES_128_CBC_SHA || ps_sslCtx->s_sslGut.ae_cipSpecs[i] == TLS_ECDHE_ECDSA_WITH_AES_256_CBC_SHA ) { ps_sslCtx->s_sslGut.ae_cipSpecs[i] = TLS_NULL_WITH_NULL_NULL; } } break; } i_state = SSL_SERVER_ACCEPT; LOG_OK("Accept"); } /* if ... else */ break; /* SSL_SERVER_LISTEN */ case SSL_SERVER_ACCEPT: /* Operates the SSL Handshake */ switch(sslSoc_accept (ps_sslCtx)) { case E_SSL_AGAIN: break; case E_SSL_OK: /* print some connection specifics */ printf("\n>INFO::Ciphers: RX = 0x%.4X, TX = 0x%.4X\n", ps_sslCtx->s_sslGut.e_rxCipSpec, ps_sslCtx->s_sslGut.e_txCipSpec); printf("\n>INFO::Version: 0x%.4X\n", ps_sslCtx->e_ver); i_state = SSL_SERVER_READ; /* Reads the current system time */ l_timeStart = fp_getCurTime(); l_Start = l_timeStart; l_bytesRead = 0; break; case E_SSL_ERROR: default: LOG_ERR("sslSoc_accept error"); i_state = SSL_SERVER_CLOSE_ERR; ps_sslCtx->e_socState = E_SSL_SOCKET_UNUSED; break; } /* switch */ break; /* SSL_SERVER_ACCEPT */ case SSL_SERVER_READ: l_bytes = 0; /* Just read and show on console. */ /* Read */ memset(c_readBuf, 0, sizeof(c_readBuf)); /* read from SSL socket */ l_bytes = sslSoc_read(ps_sslCtx, c_readBuf, sizeof(c_readBuf)); if (l_bytes > 0) { if (echo != 0) { /* server echo: transmit received byte string */ memcpy(c_writeBuf, c_readBuf, l_bytes); l_bytesWrite = l_bytes; i_state = SSL_SERVER_WRITE; } else if (strncmp(c_readBuf, "GET / HTTP/1.1\r\n\r\n", 16) == 0) { /* open file to transmit */ fp = fopen(pc_filename, "rb"); if (fp == NULL) { /* could not open file => send an error message */ l_bytesWrite = sprintf(c_writeBuf, "HTTP/1.1 404 Not Found\r\n\r\n"); i_state = SSL_SERVER_WRITE; } else { /* determine the number of bytes in the file to put * that piece of information into the HTTP header */ n = 0; while (fgetc(fp) != EOF) { n++; } rewind(fp); printf("Transmitting file: '%s'\n", pc_filename); /* prepare HTTP header */ l_bytesWrite = sprintf(c_writeBuf, "HTTP/1.1 200 OK\r\n"\ "Content-Type: application/octet-stream\r\n"\ "Content-Length: %d\r\n\r\n", n); /* next step: read first chunk of bytes from file */ i_state = SSL_SERVER_READ_FILE; } } break; } else if (l_bytes < 0) { switch(l_bytes) { case E_SSL_ERROR: i_state = SSL_SERVER_CLOSING; break; case E_SSL_WANT_WRITE: i_state = SSL_SERVER_FLUSH; break; default: break; } } else if (l_bytes == E_SSL_AGAIN) { break; } i_state = SSL_SERVER_CLOSE; break; /* SSL_SERVER_READ */ case SSL_SERVER_READ_FILE: n = 0; if (fp != NULL) { /* read chunk of bytes from file and copy to write buffer */ n = fread(c_filebuf, 1, SSL_WRITE_BLOCK_LEN - l_bytesWrite - 100, fp); } memcpy(&(c_writeBuf[l_bytesWrite]), c_filebuf, n); l_bytesWrite += n; if (n > 0) { /* next step: send data just read from file to peer */ i_state = SSL_SERVER_WRITE; } else { /* we have reached the end of the file: close file and connection */ if (fp != NULL) { fclose(fp); } i_state = SSL_SERVER_CLOSING; } break; /* case SSL_SERVER_READ_FILE */ case SSL_SERVER_WRITE: /* send data to peer */ l_bytes = sslSoc_write(ps_sslCtx, (char*)c_writeBuf, l_bytesWrite); if (l_bytes > 0) { i_state = SSL_SERVER_FLUSH; } else { switch(l_bytes) { case E_SSL_ERROR: printf(DBG_STRING " sslSoc_write error %s", __FILE__, __LINE__, sslDiag_getError(ps_sslCtx)); i_state = SSL_SERVER_CLOSING; break; case E_SSL_WANT_AGAIN: i_state = SSL_SERVER_READ; break; default: break; } } /* need to reset l_bytesWrite to zero because otherwise step * SSL_SERVER_READ_FILE would *append* new data (thinking * previous chunk of bytes from file is the HTTP header) */ l_bytesWrite = 0; break; /* case SSL_SERVER_WRITE */ case SSL_SERVER_FLUSH: { switch(sslSoc_flush(ps_sslCtx)) { case E_SSL_OK: if (echo != 0) { /* in echo mode: start listening again */ i_state = SSL_SERVER_READ; } else { /* in normal mode: read next chunk of bytes from file */ i_state = SSL_SERVER_READ_FILE; } break; /* * It is not, so we can fall thru */ case E_SSL_WANT_AGAIN: i_state = SSL_SERVER_READ; break; case E_SSL_AGAIN: break; case E_SSL_ERROR: default: i_state = SSL_SERVER_CLOSING; break; } }/* SSL_SERVER_FLUSH */ break; case SSL_SERVER_CLOSING: case SSL_SERVER_CLOSING_ERR: LOG_RAW("Shutting down SSL connection..."); do { l_bytes = sslSoc_shutdown(ps_sslCtx); printf("sslSoc_shutdown(...) returned: %d\n", l_bytes); if (l_bytes == E_SSL_OK && i_state == SSL_SERVER_CLOSING) { /* connection successfully closed (passive close) */ i_state = SSL_SERVER_CLOSE; } else if (l_bytes != E_SSL_AGAIN) { /* connection successfully closed (error case) */ i_state = SSL_SERVER_CLOSE_ERR; } } while (l_bytes != E_SSL_OK && l_bytes != E_SSL_ERROR); printf("done!\n"); break; case SSL_SERVER_CLOSE: case SSL_SERVER_CLOSE_ERR: sslSoc_free(ps_sslCtx); close(srv_socdesc); puts("Socket closed"); E_SERVER_FSM_RESULT retval = (i_state == SSL_SERVER_CLOSE_ERR) ? E_SERVER_FSM_ERROR : E_SERVER_FSM_DONE; i_state = SSL_SERVER_REINIT; return retval; break; } /* switch */ /* server FSM would like to be re-entered again */ return E_SERVER_FSM_AGAIN; }
/* This is used so often in the metadata format handlers and elsewhere. */ int log_alloc_err(struct lib_context *lc, const char *who) { LOG_ERR(lc, 0, "%s: allocating", who); }
// Distance sensor more than 1D ViewImage *CTSimObj::distanceSensorD(double start, double end, int id, bool map) { NSLookup::Provider *prov = lookupProvider(Service::DISTANCE_SENSOR); if (!prov) { LOG_ERR(("distanceSensor1D : cannot get service provider info [%s:%d]", __FILE__, __LINE__)); return false; } SOCKET sock = prov->sock(); if (sock < 0) { LOG_ERR(("distanceSensor1D : cannot connect to service provider [%s:%d]", __FILE__, __LINE__)); return false; } CommRequestDistanceSensorEncoder *enc; if(map == false) { enc = new CommRequestDistanceSensorEncoder(myname(), start, end, id, 1); } else { // Encoder for 2D distance sensor enc = new CommRequestDistanceSensorEncoder(myname(), start, end, id, 2); } // CommRequestDistanceSensorEncoder enc(myname(), id); int status = enc->send(sock); delete enc; ViewImageInfo info(IMAGE_DATA_TYPE_ANY, DEPTHBIT_8, IMAGE_320X1); ViewImage *img; CommDataDecoder d; typedef CTReader Reader; int retry; if(map == true) retry = 25; else retry = 20; Reader *r = new Reader(sock, d, 100000); while (true) { Result *result = NULL; try { result = r->readSync(); } catch(CTReader::ConnectionClosedException &e) { break; } if (!result) { if (retry <= 0) { // add(sekikawa)(2010/08/10) LOG_ERR(("readSync() failed. max retry count exceeded. [%s:%d]", __FILE__, __LINE__)); break; } else { LOG_DEBUG1(("retrying readSync() ... [retry=%d]", retry)); retry--; #ifdef WIN32 Sleep(100000); #else usleep(100000); #endif continue; } } if (result->type() == COMM_RESULT_CAPTURE_VIEW_IMAGE) { ResultCaptureViewImageEvent *evt = (ResultCaptureViewImageEvent*)result->data(); img = evt->release(); } /* if (result->type() == COMM_RESULT_DISTANCE_SENSOR1D) { ResultDistanceSensor1DEvent *evt = (ResultDistanceSensor1DEvent*)result->data(); distance = evt->getDistance(); } */ delete result; break; } prov->close(); return img; }