//------------------------------------------------------------------------------
// Main function to generate module files in current directory
//------------------------------------------------------------------------------
int main(int argc, char* argv[]){
// Strings for command line options
std::string namespace_name="";
std::string author="";
std::string email="";
// determine namespace name, author and email from command line
process_command_line(argc, argv, namespace_name, author, email);
// create file header
std::string file_header = create_file_header(author, email);
// Generate data.cpp
create_data(file_header, namespace_name);
// Generate interface.cpp
create_interface(file_header, namespace_name);
// Generate initialise.cpp
create_initialise(file_header, namespace_name);
// Generate internal.hpp
create_internal(file_header, namespace_name);
// Generate internal.hpp
create_module(file_header, namespace_name);
// Generate makefile
create_makefile(file_header, namespace_name);
return EXIT_SUCCESS;
}
static jint create(JNIEnv *env, jobject thiz, jint mtu)
{
int tun = create_interface(mtu);
if (tun < 0) {
throwException(env, tun, "Cannot create interface");
return -1;
}
return tun;
}
/** Open interface for writing.
* This will create a new interface instance of the given type. The result can be
* casted to the appropriate type. This will only succeed if there is not already
* a writer for the given interface type/id!
* @param type type of the interface
* @param identifier identifier of the interface
* @return new fully initialized interface instance of requested type
* @exception OutOfMemoryException thrown if there is not enough free space for
* the requested interface.
* @exception BlackBoardWriterActiveException thrown if there is already a writing
* instance with the same type/id
*/
Interface *
BlackBoardInterfaceManager::open_for_writing(const char *type, const char *identifier)
{
mutex->lock();
memmgr->lock();
Interface *iface = NULL;
void *ptr = NULL;
interface_header_t *ih;
bool created = false;
try {
ptr = find_interface_in_memory(type, identifier);
if ( ptr != NULL ) {
// found, check if there is already a writer
//instantiate new interface for given memory chunk
ih = (interface_header_t *)ptr;
if ( ih->flag_writer_active ) {
throw BlackBoardWriterActiveException(identifier, type);
}
iface = new_interface_instance(type, identifier);
if ( (iface->hash_size() != __INTERFACE_HASH_SIZE ) ||
(memcmp(iface->hash(), ih->hash, __INTERFACE_HASH_SIZE) != 0) ) {
throw BlackBoardInterfaceVersionMismatchException();
}
iface->set_memory(ih->serial, ptr, (char *)ptr + sizeof(interface_header_t));
rwlocks[ih->serial]->ref();
} else {
created = true;
create_interface(type, identifier, iface, ptr);
ih = (interface_header_t *)ptr;
}
iface->set_readwrite(true, rwlocks[ih->serial]);
ih->flag_writer_active = 1;
ih->refcount++;
memmgr->unlock();
writer_interfaces[ih->serial] = iface;
mutex->unlock();
if ( created ) {
notifier->notify_of_interface_created(type, identifier);
}
notifier->notify_of_writer_added(iface, iface->serial());
} catch (Exception &e) {
if (iface) delete_interface_instance(iface);
memmgr->unlock();
mutex->unlock();
throw;
}
return iface;
}
/*!
Creates a new interface.
*/
long Patch::create_interface(ElementInfo::Type type)
{
long id;
if (m_unusedInterfaceIds.empty()) {
id = m_interfaces.size();
} else {
id = m_unusedInterfaceIds.front();
m_unusedInterfaceIds.pop_front();
}
return create_interface(id, type);
}
int supplicant_start(struct connman_device *device)
{
struct supplicant_task *task;
int err;
_DBG_SUPPLICANT("device %p", device);
task = g_try_new0(struct supplicant_task, 1);
if (task == NULL)
return -ENOMEM;
task->ifindex = connman_device_get_index(device);
task->ifname = connman_inet_ifname(task->ifindex);
if (task->ifname == NULL) {
err = -ENOMEM;
goto failed;
}
task->mac80211 = connman_inet_is_mac80211(task->ifindex);
if (task->mac80211 == FALSE)
connman_warn("Enabling quirks for unsupported driver");
task->range = g_try_malloc0(sizeof(struct iw_range));
if (task->range == NULL) {
err = -ENOMEM;
goto failed;
}
err = get_range(task);
if (err < 0)
goto failed;
task->device = connman_device_ref(device);
task->created = FALSE;
task->scanning = FALSE;
task->state = WPA_INVALID;
task->disconnecting = FALSE;
task->pending_network = NULL;
task_list = g_slist_append(task_list, task);
return create_interface(task);
failed:
g_free(task->range);
g_free(task->ifname);
g_free(task);
return err;
}
status_t
add_interface_to_domain(net_domain* _domain,
struct ifreq& request)
{
net_domain_private* domain = (net_domain_private*)_domain;
const char* deviceName = request.ifr_parameter.device[0]
? request.ifr_parameter.device : request.ifr_name;
const char* baseName = request.ifr_parameter.base_name[0]
? request.ifr_parameter.base_name : request.ifr_name;
net_device_interface* deviceInterface = get_device_interface(deviceName);
if (deviceInterface == NULL)
return ENODEV;
RecursiveLocker locker(domain->lock);
net_interface_private* interface = NULL;
status_t status;
if (find_interface(domain, request.ifr_name) == NULL) {
// We must not hold the domain's link when creating the interface:
// this will call get_module() which might want to access a network
// device when booting from network.
locker.Unlock();
status = create_interface(domain, request.ifr_name,
baseName, deviceInterface, &interface);
locker.Lock();
if (find_interface(domain, request.ifr_name) != NULL) {
delete_interface(interface);
status = B_NAME_IN_USE;
}
} else
status = B_NAME_IN_USE;
put_device_interface(deviceInterface);
if (status == B_OK) {
list_add_item(&domain->interfaces, interface);
notify_interface_added(interface);
}
return status;
}
int run()
{
fd_set fds;
int max_fd;
create_interface(&interface);
running = true;
accueil = NULL;
accueil = create_channel("Accueil", 1, NULL);
set_current_channel(accueil);
while (running)
{
max_fd = init_fd(&fds);
if (select(max_fd + 1, &fds, NULL, NULL, NULL) > 0)
process_fd(&fds);
}
destroy_interface(&interface);
return (0);
}
/** Open interface for reading.
* This will create a new interface instance of the given type. The result can be
* casted to the appropriate type.
* @param type type of the interface
* @param identifier identifier of the interface
* @param owner name of entity which opened this interface. If using the BlackBoardAspect
* to access the blackboard leave this untouched unless you have a good reason.
* @return new fully initialized interface instance of requested type
* @exception OutOfMemoryException thrown if there is not enough free space for
* the requested interface.
*/
Interface *
BlackBoardInterfaceManager::open_for_reading(const char *type, const char *identifier, const char *owner)
{
if (strlen(type) > __INTERFACE_TYPE_SIZE) {
throw Exception("Interface type '%s' too long, maximum length is %zu",
type, __INTERFACE_TYPE_SIZE);
}
if (strlen(identifier) > __INTERFACE_ID_SIZE) {
throw Exception("Interface ID '%s' too long, maximum length is %zu",
type, __INTERFACE_ID_SIZE);
}
mutex->lock();
Interface *iface = NULL;
void *ptr = NULL;
interface_header_t *ih;
bool created = false;
memmgr->lock();
ptr = find_interface_in_memory(type, identifier);
try {
if ( ptr != NULL ) {
// found, instantiate new interface for given memory chunk
iface = new_interface_instance(type, identifier, owner);
ih = (interface_header_t *)ptr;
if ( (iface->hash_size() != __INTERFACE_HASH_SIZE ) ||
(memcmp(iface->hash(), ih->hash, __INTERFACE_HASH_SIZE) != 0) ) {
throw BlackBoardInterfaceVersionMismatchException();
}
iface->set_memory(ih->serial, ptr, (char *)ptr + sizeof(interface_header_t));
rwlocks[ih->serial]->ref();
} else {
created = true;
create_interface(type, identifier, owner, iface, ptr);
ih = (interface_header_t *)ptr;
}
owner_info_[iface->uid()].readers.push_back(iface);
iface->set_readwrite(false, rwlocks[ih->serial]);
ih->refcount++;
ih->num_readers++;
memmgr->unlock();
mutex->unlock();
if ( created ) {
notifier->notify_of_interface_created(type, identifier);
}
notifier->notify_of_reader_added(iface, iface->serial());
} catch (Exception &e) {
if (iface) delete_interface_instance(iface);
memmgr->unlock();
mutex->unlock();
throw;
}
return iface;
}
static void
start_element(void *data, const char *element_name, const char **atts)
{
struct parse_context *ctx = data;
struct interface *interface;
struct message *message;
struct arg *arg;
struct enumeration *enumeration;
struct entry *entry;
struct description *description = NULL;
const char *name = NULL;
const char *type = NULL;
const char *interface_name = NULL;
const char *value = NULL;
const char *summary = NULL;
const char *since = NULL;
const char *allow_null = NULL;
const char *enumeration_name = NULL;
const char *bitfield = NULL;
int i, version = 0;
ctx->loc.line_number = XML_GetCurrentLineNumber(ctx->parser);
for (i = 0; atts[i]; i += 2) {
if (strcmp(atts[i], "name") == 0)
name = atts[i + 1];
if (strcmp(atts[i], "version") == 0) {
version = strtouint(atts[i + 1]);
if (version == -1)
fail(&ctx->loc, "wrong version (%s)", atts[i + 1]);
}
if (strcmp(atts[i], "type") == 0)
type = atts[i + 1];
if (strcmp(atts[i], "value") == 0)
value = atts[i + 1];
if (strcmp(atts[i], "interface") == 0)
interface_name = atts[i + 1];
if (strcmp(atts[i], "summary") == 0)
summary = atts[i + 1];
if (strcmp(atts[i], "since") == 0)
since = atts[i + 1];
if (strcmp(atts[i], "allow-null") == 0)
allow_null = atts[i + 1];
if (strcmp(atts[i], "enum") == 0)
enumeration_name = atts[i + 1];
if (strcmp(atts[i], "bitfield") == 0)
bitfield = atts[i + 1];
}
ctx->character_data_length = 0;
if (strcmp(element_name, "protocol") == 0) {
if (name == NULL)
fail(&ctx->loc, "no protocol name given");
ctx->protocol->name = xstrdup(name);
ctx->protocol->uppercase_name = uppercase_dup(name);
} else if (strcmp(element_name, "copyright") == 0) {
} else if (strcmp(element_name, "interface") == 0) {
if (name == NULL)
fail(&ctx->loc, "no interface name given");
if (version == 0)
fail(&ctx->loc, "no interface version given");
interface = create_interface(ctx->loc, name, version);
ctx->interface = interface;
wl_list_insert(ctx->protocol->interface_list.prev,
&interface->link);
} else if (strcmp(element_name, "request") == 0 ||
strcmp(element_name, "event") == 0) {
if (name == NULL)
fail(&ctx->loc, "no request name given");
message = create_message(ctx->loc, name);
if (strcmp(element_name, "request") == 0)
wl_list_insert(ctx->interface->request_list.prev,
&message->link);
else
wl_list_insert(ctx->interface->event_list.prev,
&message->link);
if (type != NULL && strcmp(type, "destructor") == 0)
message->destructor = 1;
version = version_from_since(ctx, since);
if (version < ctx->interface->since)
warn(&ctx->loc, "since version not increasing\n");
ctx->interface->since = version;
message->since = version;
if (strcmp(name, "destroy") == 0 && !message->destructor)
fail(&ctx->loc, "destroy request should be destructor type");
ctx->message = message;
} else if (strcmp(element_name, "arg") == 0) {
if (name == NULL)
fail(&ctx->loc, "no argument name given");
arg = create_arg(name);
if (!set_arg_type(arg, type))
fail(&ctx->loc, "unknown type (%s)", type);
switch (arg->type) {
case NEW_ID:
ctx->message->new_id_count++;
/* fallthrough */
case OBJECT:
if (interface_name)
arg->interface_name = xstrdup(interface_name);
break;
default:
if (interface_name != NULL)
fail(&ctx->loc, "interface attribute not allowed for type %s", type);
break;
}
if (allow_null) {
if (strcmp(allow_null, "true") == 0)
arg->nullable = 1;
else if (strcmp(allow_null, "false") != 0)
fail(&ctx->loc,
"invalid value for allow-null attribute (%s)",
allow_null);
if (!is_nullable_type(arg))
fail(&ctx->loc,
"allow-null is only valid for objects, strings, and arrays");
}
if (enumeration_name == NULL || strcmp(enumeration_name, "") == 0)
arg->enumeration_name = NULL;
else
arg->enumeration_name = xstrdup(enumeration_name);
if (summary)
arg->summary = xstrdup(summary);
wl_list_insert(ctx->message->arg_list.prev, &arg->link);
ctx->message->arg_count++;
} else if (strcmp(element_name, "enum") == 0) {
if (name == NULL)
fail(&ctx->loc, "no enum name given");
enumeration = create_enumeration(name);
if (bitfield == NULL || strcmp(bitfield, "false") == 0)
enumeration->bitfield = false;
else if (strcmp(bitfield, "true") == 0)
enumeration->bitfield = true;
else
fail(&ctx->loc,
"invalid value (%s) for bitfield attribute (only true/false are accepted)",
bitfield);
wl_list_insert(ctx->interface->enumeration_list.prev,
&enumeration->link);
ctx->enumeration = enumeration;
} else if (strcmp(element_name, "entry") == 0) {
if (name == NULL)
fail(&ctx->loc, "no entry name given");
entry = create_entry(name, value);
version = version_from_since(ctx, since);
if (version < ctx->enumeration->since)
warn(&ctx->loc, "since version not increasing\n");
ctx->enumeration->since = version;
entry->since = version;
if (summary)
entry->summary = xstrdup(summary);
else
entry->summary = NULL;
wl_list_insert(ctx->enumeration->entry_list.prev,
&entry->link);
} else if (strcmp(element_name, "description") == 0) {
if (summary == NULL)
fail(&ctx->loc, "description without summary");
description = xzalloc(sizeof *description);
description->summary = xstrdup(summary);
if (ctx->message)
ctx->message->description = description;
else if (ctx->enumeration)
ctx->enumeration->description = description;
else if (ctx->interface)
ctx->interface->description = description;
else
ctx->protocol->description = description;
ctx->description = description;
}
}
