Ejemplo n.º 1
0
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;
}
Ejemplo n.º 2
0
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;
}
Ejemplo n.º 3
0
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;
}
Ejemplo n.º 4
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;
}
Ejemplo n.º 6
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;
}
Ejemplo n.º 7
0
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;
}
Ejemplo n.º 8
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;
}
Ejemplo n.º 9
0
/**
 * 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;
}
Ejemplo n.º 10
0
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;
}
Ejemplo n.º 11
0
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;
}
Ejemplo n.º 12
0
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;
}
Ejemplo n.º 13
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);
}
Ejemplo n.º 15
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;
}
Ejemplo n.º 16
0
/** 
 * 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;
}
Ejemplo n.º 17
0
/*****************************************************************************
  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;
}
Ejemplo n.º 18
0
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;
}
Ejemplo n.º 19
0
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;
}
Ejemplo n.º 20
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;
}
Ejemplo n.º 21
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;
}
Ejemplo n.º 22
0
int usb_dc_detach(void)
{
	LOG_ERR("Not implemented");

	return 0;
}
Ejemplo n.º 23
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);
}
Ejemplo n.º 24
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;
}
Ejemplo n.º 26
0
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);
}
Ejemplo n.º 27
0
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;
}
Ejemplo n.º 28
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;
}
Ejemplo n.º 29
0
/* 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);
}
Ejemplo n.º 30
0
// 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;
}