int udp_start(Cfg *cfg)
{
CfgGroup *grp;
Octstr *iface;
List *ifs;
int allow_wtls;
if (udp_running) return -1;
debug("bb.udp", 0, "starting UDP sender/receiver module");
grp = cfg_get_single_group(cfg, octstr_imm("core"));
iface = cfg_get(grp, octstr_imm("wdp-interface-name"));
if (iface == NULL) {
error(0, "Missing wdp-interface-name variable, cannot start UDP");
return -1;
}
allow_ip = cfg_get(grp, octstr_imm("udp-allow-ip"));
deny_ip = cfg_get(grp, octstr_imm("udp-deny-ip"));
/* we'll activate WTLS as soon as we have a 'wtls' config group */
grp = cfg_get_single_group(cfg, octstr_imm("wtls"));
allow_wtls = grp != NULL ? 1 : 0;
udpc_list = gwlist_create(); /* have a list of running systems */
ifs = octstr_split(iface, octstr_imm(";"));
octstr_destroy(iface);
while (gwlist_len(ifs) > 0) {
iface = gwlist_extract_first(ifs);
info(0, "Adding interface %s", octstr_get_cstr(iface));
add_service(9200, octstr_get_cstr(iface)); /* wsp */
add_service(9201, octstr_get_cstr(iface)); /* wsp/wtp */
#ifdef HAVE_WTLS_OPENSSL
if (allow_wtls) {
add_service(9202, octstr_get_cstr(iface)); /* wsp/wtls */
add_service(9203, octstr_get_cstr(iface)); /* wsp/wtp/wtls */
}
#else
if (allow_wtls)
error(0, "These is a 'wtls' group in configuration, but no WTLS support compiled in!");
#endif
/* add_service(9204, octstr_get_cstr(interface_name)); * vcard */
/* add_service(9205, octstr_get_cstr(interface_name)); * vcal */
/* add_service(9206, octstr_get_cstr(interface_name)); * vcard/wtls */
/* add_service(9207, octstr_get_cstr(interface_name)); * vcal/wtls */
octstr_destroy(iface);
}
gwlist_destroy(ifs, NULL);
gwlist_add_producer(incoming_wdp);
udp_running = 1;
return 0;
}
int exnode_system_config(lio_service_manager_t *ess, lio_data_service_fn_t *ds, lio_resource_service_fn_t *rs, lio_object_service_fn_t *os, gop_thread_pool_context_t *tpc_unlimited, lio_cache_t *cache)
{
add_service(ess, ESS_RUNNING, ESS_DS, ds);
add_service(ess, ESS_RUNNING, ESS_RS, rs);
add_service(ess, ESS_RUNNING, ESS_OS, os);
add_service(ess, ESS_RUNNING, ESS_TPC_UNLIMITED, tpc_unlimited);
add_service(ess, ESS_RUNNING, ESS_CACHE, cache);
return(0);
}
int telnet_init(char *banner)
{
if (strcmp(telnet_port, "disabled") == 0) {
LOG_INFO("telnet server disabled");
return ERROR_OK;
}
struct telnet_service *telnet_service =
malloc(sizeof(struct telnet_service));
if (!telnet_service) {
LOG_ERROR("Failed to allocate telnet service.");
return ERROR_FAIL;
}
telnet_service->banner = banner;
int ret = add_service("telnet", telnet_port, CONNECTION_LIMIT_UNLIMITED,
telnet_new_connection, telnet_input, telnet_connection_closed,
telnet_service);
if (ret != ERROR_OK) {
free(telnet_service);
return ret;
}
return ERROR_OK;
}
static void service_browser_callback(
AvahiServiceBrowser *b,
AvahiIfIndex interface,
AvahiProtocol protocol,
AvahiBrowserEvent event,
const char *name,
const char *type,
const char *domain,
AvahiLookupResultFlags flags,
void *userdata) {
Config *c = userdata;
assert(b);
assert(c);
switch (event) {
case AVAHI_BROWSER_NEW: {
if (c->ignore_local && (flags & AVAHI_LOOKUP_RESULT_LOCAL))
break;
if (find_service(interface, protocol, name, type, domain))
return;
add_service(c, interface, protocol, name, type, domain);
//print_service_line(c, '+', interface, protocol, name, type, domain, 1);
break;
}
case AVAHI_BROWSER_REMOVE: {
ServiceInfo *info;
if (!(info = find_service(interface, protocol, name, type, domain)))
return;
remove_service(c, info);
//print_service_line(c, '-', interface, protocol, name, type, domain, 1);
break;
}
case AVAHI_BROWSER_FAILURE:
fprintf(stderr, ("service_browser failed: %s\n"), avahi_strerror(avahi_client_errno(client)));
avahi_simple_poll_quit(simple_poll);
break;
case AVAHI_BROWSER_CACHE_EXHAUSTED:
n_cache_exhausted --;
check_terminate(c);
break;
case AVAHI_BROWSER_ALL_FOR_NOW:
n_all_for_now --;
check_terminate(c);
break;
}
}
static int
it_start (direntry *d, void *data)
{
if (*d->d_name == '.')
return 0;
tain_now_g ();
add_service (d->d_name, NULL);
return 0;
}
int init_services()
{
int ret =0;
if (add_service(&info_service) != NULL)
ret = 1;
return ret;
}
static void operserv_config_ready(void *unused)
{
if (opersvs.me)
del_service(opersvs.me);
opersvs.me = add_service(opersvs.nick, opersvs.user,
opersvs.host, opersvs.real, oservice);
opersvs.disp = opersvs.me->disp;
hook_del_hook("config_ready", operserv_config_ready);
}
int tcl_init(void)
{
if (strcmp(tcl_port, "disabled") == 0) {
LOG_INFO("tcl server disabled");
return ERROR_OK;
}
return add_service("tcl", tcl_port, 1,
&tcl_new_connection, &tcl_input,
&tcl_closed, NULL);
}
ci_service_module_t *register_service(char *service_file)
{
ci_service_module_t *service;
service = create_service(service_file);
if (!service) {
ci_debug_printf(1, "Error finding symbol \"service\" in module %s\n",
service_file);
return NULL;
}
return add_service(service);
}
void _modinit(module_t *m)
{
hook_add_event("config_ready");
hook_add_hook("config_ready", operserv_config_ready);
if (!cold_start)
{
opersvs.me = add_service(opersvs.nick, opersvs.user,
opersvs.host, opersvs.real, oservice);
opersvs.disp = opersvs.me->disp;
}
}
void _modinit(module_t *m)
{
hook_add_event("config_ready");
hook_add_hook("config_ready", userserv_config_ready);
if (!cold_start)
{
usersvs.me = add_service(usersvs.nick, usersvs.user,
usersvs.host, usersvs.real, userserv);
usersvs.disp = usersvs.me->disp;
}
authservice_loaded++;
}
int jsp_init(struct or1k_jtag *jtag_info, char *banner)
{
struct jsp_service *jsp_service = malloc(sizeof(struct jsp_service));
jsp_service->banner = banner;
jsp_service->jtag_info = jtag_info;
return add_service("jsp",
jsp_port,
1,
jsp_new_connection,
jsp_input,
jsp_connection_closed,
jsp_service);
}
static void add_services(obs_property_t list, const char *file, json_t *root)
{
json_t *service;
size_t index;
if (!json_is_array(root)) {
blog(LOG_WARNING, "rtmp-common.c: [add_services] JSON file "
"'%s' root is not an array", file);
return;
}
json_array_foreach (root, index, service) {
add_service(list, service);
}
/*
* this function receives an WDP message and checks if a UDP
* service for this client has to be created
*/
static int udp_addwdp_from_client(Msg *msg)
{
Udpc *udpc;
Octstr *map_addr;
Octstr *os;
Octstr *source;
if (!udp_running) return -1;
assert(msg != NULL);
assert(msg_type(msg) == wdp_datagram);
/*
* Check if there is allready a bound UDP port for this mapping.
* If not create a mapping and bind the mapped UDP port
* The mapped port is simply 2x of the client port.
*/
if ((udpc = udpc_find_mapping(msg, 1)) == NULL) {
info(0, "Creating UDP mapping <%s:%ld> <-> <%s:%ld>",
octstr_get_cstr(msg->wdp_datagram.source_address),
msg->wdp_datagram.source_port,
octstr_get_cstr(msg->wdp_datagram.destination_address),
msg->wdp_datagram.source_port*2);
map_addr = udp_create_address(msg->wdp_datagram.source_address,
msg->wdp_datagram.source_port);
add_service(msg->wdp_datagram.source_port * 2,
octstr_get_cstr(interface_name), map_addr);
/* now we should find it in the udpc_list */
if ((udpc = udpc_find_mapping(msg, 1)) == NULL)
panic(0,"Could not find UDP mapping, internal error");
}
/* now swap the message addressing */
octstr_destroy(msg->wdp_datagram.source_address);
octstr_destroy(msg->wdp_datagram.destination_address);
os = octstr_duplicate(interface_name);
source = udp_create_address(os, msg->wdp_datagram.source_port * 2);
msg->wdp_datagram.source_address = udp_get_ip(source);
msg->wdp_datagram.source_port = udp_get_port(source);
msg->wdp_datagram.destination_address = octstr_duplicate(wapgw);
msg->wdp_datagram.destination_port = CONNECTION_ORIENTED_PORT;
octstr_destroy(os);
gwlist_produce(udpc->outgoing_list, msg);
return -1;
}
static void add_services(obs_property_t *list, json_t *root, bool show_all,
const char *cur_service)
{
json_t *service;
size_t index;
if (!json_is_array(root)) {
blog(LOG_WARNING, "rtmp-common.c: [add_services] JSON file "
"root is not an array");
return;
}
json_array_foreach (root, index, service) {
add_service(list, service, show_all, cur_service);
}
static int udp_start(Cfg *cfg)
{
if (udp_running) return -1;
debug("wap.proxy", 0, "starting UDP sender/receiver module");
udpc_list = gwlist_create(); /* have a list of running systems */
add_service(server_port, octstr_get_cstr(interface_name), NULL); /* wsp/wtp */
gwlist_add_producer(incoming_wdp);
udp_running = 1;
return 0;
}
bluetoothtoken_t * initBluetooth(const char *h, const int p)
{
hostname = h;
portno = p;
int s;
uuid_t svc_uuid;
struct sockaddr_rc rem_addr = { 0 };
socklen_t opt = sizeof(rem_addr);
// allocate socket
if((s = socket(AF_BLUETOOTH, SOCK_STREAM, BTPROTO_RFCOMM)) <= 0) {
logError("failed to bind bluetooth socket: %d", s);
return NULL;
}
loc_addr.rc_family = AF_BLUETOOTH;
loc_addr.rc_bdaddr = *BDADDR_ANY;
loc_addr.rc_channel = (uint8_t) 10;
if((bind(s, (struct sockaddr *)&loc_addr, sizeof(loc_addr))) == -1) {
logError("failed to bind bluetooth socket");
close(s);
return NULL;
}
logDebug("BT bound to channel %d", loc_addr.rc_channel);
// put socket into listening mode
if(listen(s, 1) == -1) {
logError("failed to setup listening mode");
close(s);
return NULL;
}
sdpSession = sdp_connect( BDADDR_ANY, BDADDR_LOCAL, SDP_RETRY_IF_BUSY );
if(add_service(sdpSession, &recordHandle, loc_addr.rc_channel) < 0) {
logError("failed to register service @ SDP");
recordHandle = 0;
}
// sdpSession = register_service(loc_addr.rc_channel);
bluetoothtoken_t* btp = (bluetoothtoken_t*)malloc(sizeof(bluetoothtoken_t));
btp->s = s;
//not used yet:
// pthread_mutex_init(&btp->mutex, NULL);
// pthread_cond_init(&btp->condition, NULL);
return btp;
}
static void userserv_config_ready(void *unused)
{
if (usersvs.me)
del_service(usersvs.me);
usersvs.me = add_service(usersvs.nick, usersvs.user,
usersvs.host, usersvs.real, userserv);
usersvs.disp = usersvs.me->disp;
if (nicksvs.nick)
{
slog(LG_ERROR, "idiotic conf detected: userserv enabled but nickserv{} block present, ignoring nickserv");
free(nicksvs.nick);
nicksvs.nick = NULL;
}
hook_del_hook("config_ready", userserv_config_ready);
}
int telnet_init(char *banner)
{
if (strcmp(telnet_port, "disabled") == 0) {
LOG_INFO("telnet server disabled");
return ERROR_OK;
}
struct telnet_service *telnet_service = malloc(sizeof(struct telnet_service));
telnet_service->banner = banner;
return add_service("telnet",
telnet_port,
1,
telnet_new_connection,
telnet_input,
telnet_connection_closed,
telnet_service);
}
json_object* mico_get_device_info(struct mico_service_t service_table[])
{
OSStatus err = kUnknownErr;
properties_log_trace();
json_object *dev_info_obj = NULL, *services = NULL, *properties = NULL;
int service_index = 0, property_index = 0;
const char *pServiceType = NULL;
const char *pPropertyType = NULL;
int iid = 1;
services = json_object_new_array();
require( services, exit );
err = add_top(&dev_info_obj, MICO_PROP_KEY_RESP_SERVICES, services);
for(service_index = 0, pServiceType = service_table[0].type; NULL != pServiceType; ){
properties = json_object_new_array();
require_action( properties, exit, err = kNoResourcesErr );
err = add_service(services, "type", pServiceType,
"iid", iid, "properties", properties);
require_noerr( err, exit );
iid++;
for(property_index = 0, pPropertyType = service_table[service_index].properties[0].type; NULL != pPropertyType; ){
err = add_property(properties, service_table[service_index].properties[property_index], iid);
require_noerr( err, exit );
iid++;
property_index++;
pPropertyType = service_table[service_index].properties[property_index].type;
}
service_index++;
pServiceType = service_table[service_index].type;
}
exit:
if(err != kNoErr && dev_info_obj){
properties_log("ERROR: get_device_info err, err=%d", err);
json_object_put(dev_info_obj);
dev_info_obj = NULL;
}
return dev_info_obj;
}
/* handle server requests */
void handle_server_request(int sockfd, char *recv_text, char **own_service_table, struct ServiceList *service_list, char *own_server_name){
send_service_list_info(sockfd, own_server_name, own_service_table, service_list);
char *saveptr1;
char buff[strlen(recv_text)+1];
strcpy(buff, recv_text);
pthread_mutex_lock(&handler_mutex); /* lock */
char *str = strtok_r(buff, "\n", &saveptr1);
str = strtok_r(NULL, "\n", &saveptr1);
char server_name[strlen(str)+1];
strcpy(server_name, str);
str = strtok_r(NULL, "\n", &saveptr1);
while( str != NULL ){
struct service *service_iter; /*iterator of service_list */
for(service_iter = service_list->head; service_iter != NULL; service_iter = service_iter->next){
if( strcmp(service_iter->function, str)==0 ){ /* found the function in service_list */
add_node(service_iter->server_list, server_name); /* add the server to the server_list */
break;
}
}
if(service_iter == NULL){ /* the service is not in service_list */
add_service(service_list, str, server_name); /* add the service to service_list */
}
str = strtok_r(NULL, "\n", &saveptr1);
}
pthread_mutex_unlock(&handler_mutex); /* unlock */
printf("------ Current Data Structure ------\n");
struct service *service_iter;
for(service_iter = service_list->head; service_iter != NULL; service_iter = service_iter->next){
printf("service: %s", service_iter->function);
struct node *server_iter;
for (server_iter = service_iter->server_list->head; server_iter != NULL; server_iter = server_iter->next){
printf(" -> %s:%d", server_iter->serv_name, server_iter->port);
}
printf("\n");
}
printf("------------------------------------\n\n");
/* close connection */
close(sockfd);
}
gint ConnmanManager::request_services_sync() {
GVariant *ret = NULL;
GVariantIter *iter, *iter2;
gchar *object_path;
GVariant *dict = NULL;
gsize length = 0;
ConnmanService *service = NULL, *active_service = NULL;
GList *list_networks_update = NULL;
GList *list_networks_invalid = NULL;
INetwork *network = NULL;
gint i = 0;
gboolean first_service = TRUE;
DBG3();
ret = call_sync("GetServices", NULL);
if(ret == NULL) {
ERR("call error.");
return -1;
}
g_static_mutex_lock(&services_mutex);
DBG("reply '%p'", ret);
g_variant_get(ret, "(a(oa{sv}))", &iter);
while(g_variant_iter_loop(iter, "(oa{sv})", &object_path, &iter2)) {
gchar *key;
GVariant *value;
DBG("service '%s'", object_path);
service = lookup_service(object_path);
if(service == NULL) {
DBG("service '%s' does not yet exist, create one.", object_path);
service = create_service(object_path);
if(service != NULL) {
add_service(service);
service->set_updated(TRUE);
}
else {
ERR("creating service.");
continue;
}
}
else {
DBG("service '%s' exist, update values.", object_path);
}
if(first_service == TRUE) {
first_service = FALSE;
active_service = service;
}
service->set_active_service(active_service);
while(g_variant_iter_loop(iter2, "{sv}", &key, &value)) {
if(g_strcmp0(key, "Type") == 0) {
if(value && g_variant_is_of_type(value, G_VARIANT_TYPE_STRING)) {
const gchar *help = g_variant_get_string(value, &length);
eRat rat = string2Rat(help);
DBG3("Type string '%s', enum '%u'", help, rat);
service->set_rat(rat);
}
else {
ERR("parsing 'Type'");
}
}
else if(g_strcmp0(key, "Name") == 0) {
if(value && g_variant_is_of_type(value, G_VARIANT_TYPE_STRING)) {
const gchar *help = g_variant_get_string(value, &length);
DBG3("Name '%s'", help);
service->set_name(help);
}
else {
ERR("parsing 'Name'");
}
}
else if(g_strcmp0(key, "State") == 0) {
if(value && g_variant_is_of_type(value, G_VARIANT_TYPE_STRING)) {
const gchar *help = g_variant_get_string(value, &length);
DBG3("State string '%s', enum '%u'", help, string2State(help));
service->set_state(string2State(help));
}
else {
ERR("parsing 'State'");
}
}
else if(g_strcmp0(key, "Strength") == 0) {
if(value && g_variant_is_of_type(value, G_VARIANT_TYPE_BYTE)) {
guint8 help = g_variant_get_byte(value);
DBG3("Strength '%u'", help);
service->set_strength(help);
}
else {
ERR("parsing 'Strength'");
}
}
} // End dictionary/ one service
i++;
/* set service as visited, to delete invalid services afterwards. */
service->set_visited(TRUE);
/* create network */
if(service->get_updated() == FALSE)
continue;
if((service->get_rat() == RatWifi)) {
DBG2("Network wifi");
network = new Wlan(service->get_object_path());
if(network == NULL) {
ERR("network '%s' with object path '%s'", rat2String(RatWifi), service->get_object_path());
delete network;
continue;
}
}
else if(service->get_rat() == RatQmi) {
DBG2("Network qmi");
network = new Qmi(service->get_object_path());
if(network == NULL) {
ERR("network '%s' with object path '%s'", rat2String(RatQmi), service->get_object_path());
delete network;
continue;
}
}
else {
continue;
}
service->set_updated(FALSE);
network->set_strength(service->get_strength());
network->set_strength_average((service->get_strength_average()));
network->set_state(service->get_state());
network->set_name((service->get_name()));
list_networks_update = g_list_prepend(list_networks_update, network);
} // End all services
DBG2("NETWORKS '%d'", i);
/* delete not visited (invalid) services and set visited to FALSE */
list_networks_invalid = delete_invalid_services();
DataStorage::get_instance()->update_networks(list_networks_update, list_networks_invalid);
g_static_mutex_unlock(&services_mutex);
g_list_free(list_networks_update);
g_list_free(list_networks_invalid);
g_variant_iter_free(iter);
g_variant_unref(ret);
return 0;
}
/*
** Basic service organization ETSI EN 300 401 V1.3.3 (2001-05), 6.3.1, P.47
*/
int fig_0_2(int figlen, int pd, int oe, int cn, unsigned char* fig)
{
union {
struct mscstau maup;
struct mscstdat mdtp;
struct fidc fp;
struct mscpktdat mpkp;
} scdp;
struct ssid ssidp;
struct lsid lsidp;
short s, scmp;
int f, i, j, k, sid;
#if DEBUG > 2
fprintf(stderr, "fig_0_2: ");
for (i=0; i < figlen; i++)
fprintf(stderr, "%#02x ",*(fig + i));
fprintf(stderr, "\n");
#endif
i = einf.num_srvs;
j = figlen;
while (j > 0) {
#if DEBUG > 1
fprintf(stderr, "fig_0_2: j = %d\n",j);
#endif
if (pd) {
f = ipack(fig);
memcpy(&lsidp, &f, sizeof(struct lsid));
#if DEBUG > 0
fprintf(stderr, "fig_0_2: long SId = %#08x",f);
#endif
sid = f;
fig += 4;
j -= 4;
} else {
s = spack(fig);
memcpy(&ssidp, &s, sizeof(struct ssid));
#if DEBUG > 0
fprintf(stderr, "fig_0_2: short SId = %#04hx",s);
#endif
sid = (unsigned short)s;
fig += 2;
j -= 2;
}
#if DEBUG > 0
fprintf(stderr, " NumSCmp = %d\n",((struct lcn*)fig)->NumSCmp);
#endif
scmp = ((struct lcn*)fig)->NumSCmp;
fig++;
j--;
for (k=0; k < scmp; k++) {
s = spack(fig);
memcpy(&scdp.maup, &s, sizeof(struct mscstau));
/* Can this be speeded up ? */
switch (scdp.maup.TMId) {
case 0:
#if DEBUGd > 0
fprintf(stderr, "fig_0_2: TMId=%d, ASCTy=%d, SubChId=%d, Primary=%d, CAFlag=%d\n",
scdp.maup.TMId,scdp.maup.ASCTy,scdp.maup.SubChId,
scdp.maup.Primary,scdp.maup.CAFlag);
#endif
add_service(&einf, &scdp.maup, sid);
break;
case 1:
#if DEBUGd > 0
fprintf(stderr, "fig_0_2: TMId=%d, DSCTy=%d, SubChId=%d, Primary=%d, CAFlag=%d\n",
scdp.mdtp.TMId,scdp.mdtp.DSCTy,scdp.mdtp.SubChId,
scdp.mdtp.Primary,scdp.mdtp.CAFlag);
#endif
break;
case 2:
#if DEBUGd > 0
fprintf(stderr, "fig_0_2: TMId=%d, DSCTy=%d, FIDCId=%d, Primary=%d, CAFlag=%d\n",
scdp.fp.TMId,scdp.fp.DSCTy,scdp.fp.FIDCId,
scdp.fp.Primary,scdp.fp.CAFlag);
#endif
break;
case 3:
#if DEBUGd > 0
fprintf(stderr, "fig_0_2: TMId=%d, SCId=%d, Primary=%d, CAFlag=%d\n",
scdp.mpkp.TMId,scdp.mpkp.SCId,scdp.mpkp.Primary,
scdp.mpkp.CAFlag);
#endif
break;
default:
fprintf(stderr, "fig_0_2: error out of range TMId = %d\n",scdp.maup.TMId);
break;
}
fig += 2;
j -= 2;
}
i++;
}
return 0;
}
ServiceManager::ServiceManager() {
add_service(SharedPointer<IProcessor>(new BaseProcessor));
}
/* update the service list */
void recv_service_list_info(int sockfd, struct ServiceList *service_list){
char *buff = recv_once(sockfd);
char *saveptr1, *saveptr2;
char *str, *substr;
pthread_mutex_lock(&handler_mutex); /* lock */
/*printf("-----------------\n");
printf("%s", buff);
printf("-----------------\n");*/
str = strtok_r(buff, "\n", &saveptr1);
char server_name[strlen(str)+1];
strcpy(server_name, str);
str = strtok_r(NULL, "\n", &saveptr1);
while( strcmp(str, "TABLE") != 0 ){
substr = strtok_r(str, "&", &saveptr2);
struct service *service_iter;
for(service_iter = service_list->head; service_iter != NULL; service_iter = service_iter->next){
if( strcmp(service_iter->function, substr)==0 ){
break;
}
}
if(service_iter == NULL){
add_empty_service(service_list, substr);
service_iter = service_list->tail;
}
char *s = (char*)malloc(1000*sizeof(char));
char *port = (char*)malloc(1000*sizeof(char));
while( (substr=strtok_r(NULL, "&", &saveptr2)) != NULL){
struct node *server_iter;
for (server_iter=service_iter->server_list->head; server_iter != NULL; server_iter = server_iter->next){
strcpy(s, server_iter->serv_name);
strcat(s, ":");
sprintf(port, "%d", server_iter->port);
strcat(s, port);
if( strcmp(s, substr)==0 ){
break;
}
}
if(server_iter == NULL){
add_node(service_iter->server_list, substr);
}
}
free(port);
free(s);
str = strtok_r(NULL, "\n", &saveptr1);
}
char *s = (char*)malloc(1000*sizeof(char));
char *port = (char*)malloc(1000*sizeof(char));
while( (str=strtok_r(NULL, "\n", &saveptr1)) != NULL ){
struct service *service_iter; /*iterator of service_list */
for(service_iter = service_list->head; service_iter != NULL; service_iter = service_iter->next){
if( strcmp(service_iter->function, str)==0 ){ /* found the function in service_list */
struct node *server_iter;
for(server_iter=service_iter->server_list->head; server_iter != NULL; server_iter=server_iter->next){
strcpy(s, server_iter->serv_name);
strcat(s, ":");
sprintf(port, "%d", server_iter->port);
strcat(s, port);
if(strcmp(s, server_name)==0){
break;
}
}
if(server_iter == NULL){
add_node(service_iter->server_list, server_name); /* add the server to the server_list */
}
break;
}
}
if(service_iter == NULL){ /* the service is not in service_list */
add_service(service_list, str, server_name); /* add the service to service_list */
}
}
free(s);
free(port);
printf("------ Current Data Structure ------\n");
struct service *service_iter;
for(service_iter = service_list->head; service_iter != NULL; service_iter = service_iter->next){
printf("service: %s", service_iter->function);
struct node *server_iter;
for (server_iter = service_iter->server_list->head; server_iter != NULL; server_iter = server_iter->next){
printf(" -> %s:%d", server_iter->serv_name, server_iter->port);
}
printf("\n");
}
printf("------------------------------------\n\n");
pthread_mutex_unlock(&handler_mutex); /* unlock */
/* free */
free(buff);
}
int main(void)
{
int sockfd, client_fd; // listen on sock_fd, new connection on client_fd
struct addrinfo hints, *servinfo, *p;
struct sockaddr_storage their_addr; // connector's address information
socklen_t sin_size;
struct sigaction sa;
int yes=1;
char s[INET6_ADDRSTRLEN];
int rv;
int pid=0;
int numbytes=0, bleft=0;//recv and sepected bytes in packets
int request_type;
char buff[_MAX_PACKET_LEN_];//used to receive the packet from client part,
//regarless of whether it is a server or client(in view of mapper)
char workbuff[_MAX_WORK_LEN_];//used to deal with packet command
char *tp=NULL;//used for set the pointer of msg buffer
memset((char*)buff,0,_MAX_PACKET_LEN_);
memset((char*)workbuff,0,_MAX_WORK_LEN_);
/*-----------------------Shared memory init---------------------------*/
int shm_bitmap_id = 0, shm_server_id =0, shm_mapper_id=0;
if((shm_bitmap_id=shmget(_SHM_BITMAP_ID_,_SHM_BITMAP_NODE_,IPC_CREAT | 0666 ))<0){
perror("shmget");
exit(1);
}
if((shm_server_id=shmget(_SHM_SERVER_ID_,_SHM_SERVER_NODE_,IPC_CREAT | 0666 ))<0){
perror("shmget");
exit(1);
}
if((shm_mapper_id=shmget(_SHM_MAPPER_ID_,_SHM_MAPPER_NODE_,IPC_CREAT | 0666 ))<0){
perror("shmget");
exit(1);
}
if ((shm = shmat(shm_bitmap_id, NULL, 0)) == (char *) -1) {
perror("shmat");
exit(1);
}
page_bitmap=(unsigned long long*)shm;
if ((shm = shmat(shm_server_id, NULL, 0)) == (char *) -1) {
perror("shmat");
exit(1);
}
seg_heap=(Server*)shm;
if ((shm = shmat(shm_mapper_id, NULL, 0)) == (char *) -1) {
perror("shmat");
exit(1);
}
Mapper=(Mapper_item*)shm;
initial_mapper();
/*------------------------Internet Settings Init-------------------------*/
struct sockaddr_in local;
int len=sizeof(local);
if((sockfd=socket(AF_INET,SOCK_STREAM,0))==-1){
perror("socket error at mapper");
exit(-1);
}
local.sin_family=AF_INET;
local.sin_addr.s_addr=INADDR_ANY;
local.sin_port=0;
bind(sockfd,(struct sockaddr *)&local,sizeof(local));
/*Find out and publish socket name */
getsockname(sockfd,(struct sockaddr *)&local,&len);
printf("Socket has port %d\n",local.sin_port);
system("./ip_writer > localip");
usleep(500);
sprintf((char*)buff,"echo \"%d\" >> localip ",local.sin_port);
system(buff);
memset((char*)buff,0,_MAX_PACKET_LEN_);
/*---------------------Main Loop: listen and fork process to handle-----------------*/
if (listen(sockfd, BACKLOG) == -1) {
perror("listen");
exit(1);
}
sa.sa_handler = sigchld_handler; // reap all dead processes
sigemptyset(&sa.sa_mask);
sa.sa_flags = SA_RESTART;
if (sigaction(SIGCHLD, &sa, NULL) == -1) {
perror("sigaction");
exit(1);
}
printf("server: waiting for connections...\n");
for(;;) { // main accept() loop
sin_size = sizeof their_addr;
client_fd = accept(sockfd, (struct sockaddr *)&their_addr, &sin_size);
if (client_fd == -1) {
perror("accept");
continue;
}
inet_ntop(their_addr.ss_family,
get_in_addr((struct sockaddr *)&their_addr),
s, sizeof s);
printf("mapper: got connection from %s\n", s);
//fork another process to deal with all the messages
if ( (pid = fork())==0 ) { // this is the child process
close(sockfd); //close listening process
//receive first message from ourside
if((numbytes = recv(client_fd,buff,_MAX_PACKET_LEN_-1 ,0))==-1){
//limit the recv number: _MAX_PACKET_LEN_-1: cause the max return value will be _MAX_WORK_LEN_-1,
//then if we use the statment ment as follow will not cause core dump
perror("recv");
fprintf(stderr,"recv:=%d\n, message:=%s\n",numbytes,buff);
exit(1);
}
if(!numbytes){
fprintf(stdout,"client has closed the connect\n");
exit(2);
}
tp=(char*)workbuff;
memcpy((char*)tp,(char*)buff,numbytes*sizeof(char));
tp+=numbytes;
memset((char*)buff,0,_MAX_PACKET_LEN_);
//read lenth message
//attention: there is a $ here
if(!sscanf(workbuff,"$%d#%d",&bleft,&request_type)){
fprintf(stdout,"buff is empty");
exit(2);
}
printf("\t+expected lenth next:=%d\n",bleft);
bleft-=numbytes;
int buffer_left=_MAX_WORK_LEN_-numbytes-1;//left space for '\0'
//keep reading if there is not comming to the end
while( bleft > 0 && buffer_left>0){
if((numbytes = recv(client_fd,buff,_MAX_PACKET_LEN_,0))==-1){
perror("recv");
fprintf(stderr,"recv:=%d\n, message:=%s\n",numbytes,buff);
exit(1);
}
if(!numbytes){
fprintf(stdout,"client has closed the connect\n");
exit(2);
}
memcpy(tp,buff,MIN(buffer_left,numbytes)*sizeof(char));//copy all the data received
memset(buff,0,_MAX_PACKET_LEN_*sizeof(char));
tp+=MIN(buffer_left,numbytes);
buffer_left-=MIN(buffer_left,numbytes);
bleft-=numbytes;
}
if(buffer_left>0){//means bleft=0
*tp='\0';
}
else{//means buffer_left<0
fprintf(stderr,"ivalied client parameter\n");
exit(1);
}
//the buff has already been filled up, get the whole message
char procname[PROC_NAME_LENGTH],*procn=NULL,*ttp=NULL;
int version,port;
int flag=0;
char ipname[INET6_ADDRSTRLEN];
memset((char*)procname,0,PROC_NAME_LENGTH);
get_peername(client_fd, ipname, INET6_ADDRSTRLEN, &port);
Server* tserver=NULL;
switch(request_type){
case 1://regitster
//unpack_stom_reg_msg((char *)workbuff, (char *)procname, &version);
ttp=(char*)workbuff+7;
printf("\t+type1: add server#\n");
//procn=(char*)ipname;
//while((*ttp)!='#') *procn++=*ttp++; *procn='\0';
sscanf(ttp,"#%d",&port);
for(++ttp;*ttp!='#';++ttp);
while((*ttp)!='$'){
ttp++;
procn=(char*)procname;
while((*ttp)!='#') *procn++ = *ttp++;
*procn='\0';
if(!sscanf(ttp,"#%d",&version)){
fprintf(stdout,"ttp is empty");
exit(2);
}
if(add_service((char*)procname,version,ipname,port)){
perror("addserver");
sprintf((char*)buff, "$0000#2#0#%s#%d#%s#%d$",(char*)procname,version,ipname,port);
set_pack_len(buff,strlen(buff));
flag=1;
break;
}
memset((char*)procname,0,PROC_NAME_LENGTH);
++ttp;
while((*ttp)!='#' && (*ttp)!='$') ++ttp;
}
if(!flag)
{
sprintf((char*)buff, "$0000#2#1$");
set_pack_len(buff,strlen(buff));
print_mapper();
}
bleft=strlen(buff);
while(bleft>0){
if ((numbytes = send(client_fd, buff, strlen(buff)+1,0))==-1)
{
perror("Sent");
exit(1);
}
bleft-=numbytes;
}
break;
case 3://lookup
//unpack_ctom_qry_msg((char *)workbuff, (char *)procname, &version);
ttp=(char*)workbuff+8;
printf("\t+type2: lookup a server#\n");
printf("type: %s\n",ttp);
procn=(char*)procname;
while((*ttp)!='#' && (*ttp)!='$' ) *procn++ = *ttp++; *procn='\0';
if(!sscanf(ttp,"#%d",&version)){
fprintf(stdout,"ttp is empty");
exit(2);
}
printf("\t+lookup for %s %d\n",procname,version);
tserver = lookup_service((char*)procname, version);
if(!tserver){//find nothing: there is no avail server could help
//pack_mtoc_qry_msg((char*)buff, 0, NULL, 0);
sprintf((char*)buff, "$0000#0$");
}
else{//we find one server could help
sprintf((char*)buff, "$0000#1#%s#%d$",(char*)(tserver->addstr),tserver->port);
//pack_mtoc_qry_msg((char*)buff,1,(char*)(tserver->addstr), tserver->port);
}
set_pack_len(buff,strlen(buff));
bleft=strlen(buff);
while(bleft>0){
if ((numbytes = send(client_fd, buff, strlen(buff)+1,0))==-1)
{
perror("Sent");
exit(1);
}
bleft-=numbytes;
}
break;
default://error:
fprintf(stderr,"ivaled type");
printf("\tivalued type\n");
exit(1);
}
printf("\tworkbuff:=%s\n",workbuff);
close(client_fd);
exit(0);
}
close(client_fd); // parent doesn't need this
}
return 0;
}
int server_main(void)
{
int fd, r, len;
void *binder, *cookie;
bwr_t bwr;
unsigned char rbuf[RBUF_SIZE], *p;
bcmd_txn_t *reply;
tdata_t *tdata = NULL;
inst_buf_t *inst;
inst_entry_t copy;
if (!share_cpus) {
cpu_set_t cpuset;
CPU_ZERO(&cpuset);
CPU_SET(0, &cpuset);
r = sched_setaffinity(0, sizeof(cpuset), &cpuset);
if (!r)
printf("server is bound to CPU 0\n");
else
fprintf(stderr, "server failed to be bound to CPU 0\n");
}
fd = open("/dev/binder", O_RDWR);
if (fd < 0) {
fprintf(stderr, "failed to open binder device\n");
return -1;
}
#if (!defined(INLINE_TRANSACTION_DATA))
if (mmap(NULL, 128 * 1024, PROT_READ, MAP_PRIVATE, fd, 0) == MAP_FAILED) {
fprintf(stderr, "server failed to mmap shared buffer\n");
return -1;
}
#endif
binder = SVC_BINDER;
cookie = SVC_COOKIE;
r = add_service(fd, binder, cookie, service, sizeof(service) / 2);
if (r < 0) {
printf("server failed to add instrumentation service\n");
return -1;
}
printf("server added instrumentation service\n");
r = start_looper(fd);
if (r < 0) {
printf("server failed to start looper\n");
return -1;
}
bwr.read_buffer = (unsigned long)rbuf;
while (1) {
bwr.read_size = sizeof(rbuf);
bwr.read_consumed = 0;
bwr.write_size = 0;
ioctl_read++;
r = ioctl(fd, BINDER_WRITE_READ, &bwr);
if (r < 0) {
fprintf(stderr, "server failed ioctl\n");
return r;
}
INST_RECORD(©);
p = rbuf;
len = bwr.read_consumed;
while (len > 0) {
r = server_parse_command(p, len, &tdata, &reply);
//hexdump(tdata, bwr.read_consumed);
if (r < 0)
return r;
p += r;
len -= r;
#if (defined(SIMULATE_FREE_BUFFER) || !defined(INLINE_TRANSACTION_DATA))
if (tdata)
FREE_BUFFER(fd, (void *)tdata->data.ptr.buffer);
#endif
if (!reply) {
//hexdump(rbuf, bwr.read_consumed);
continue;
}
inst = (inst_buf_t *)reply->tdata.data.ptr.buffer;
INST_ENTRY_COPY(inst, "S_RECV", ©);
//acsiidump(inst,sizeof(*inst)+data_SZ);
bwr.write_buffer = (unsigned long)reply;
bwr.write_size = sizeof(*reply);
bwr.write_consumed = 0;
bwr.read_size = 0;
INST_ENTRY(inst, "S_REPLY");
ioctl_write++;
r = ioctl(fd, BINDER_WRITE_READ, &bwr);
if (r < 0) {
fprintf(stderr, "server failed reply ioctl\n");
return r;
}
#if (!defined(INLINE_TRANSACTION_DATA))
free(reply);
#endif
}
}
free(reply);
return 0;
}
int
main (int argc, char * const argv[])
{
PROG = "aa-start";
const char *path_repo = "/run/services";
const char *path_list = NULL;
int i;
aa_secs_timeout = DEFAULT_TIMEOUT_SECS;
for (;;)
{
struct option longopts[] = {
{ "double-output", no_argument, NULL, 'D' },
{ "help", no_argument, NULL, 'h' },
{ "listdir", required_argument, NULL, 'l' },
{ "dry-list", no_argument, NULL, 'n' },
{ "repodir", required_argument, NULL, 'r' },
{ "timeout", required_argument, NULL, 't' },
{ "version", no_argument, NULL, 'V' },
{ "verbose", no_argument, NULL, 'v' },
{ "no-wants", no_argument, NULL, 'W' },
{ NULL, 0, 0, 0 }
};
int c;
c = getopt_long (argc, argv, "Dhl:nr:t:VvW", longopts, NULL);
if (c == -1)
break;
switch (c)
{
case 'D':
aa_set_double_output (1);
break;
case 'h':
dieusage (0);
case 'l':
unslash (optarg);
path_list = optarg;
break;
case 'n':
if (mode & AA_MODE_IS_DRY)
mode |= AA_MODE_IS_DRY_FULL;
else
mode |= AA_MODE_IS_DRY;
break;
case 'r':
unslash (optarg);
path_repo = optarg;
break;
case 't':
if (!uint0_scan (optarg, &aa_secs_timeout))
aa_strerr_diefu2sys (ERR_IO, "set default timeout to ", optarg);
break;
case 'V':
aa_die_version ();
case 'v':
verbose = 1;
break;
case 'W':
no_wants = 1;
break;
default:
dieusage (1);
}
}
argc -= optind;
argv += optind;
cols = get_cols (1);
is_utf8 = is_locale_utf8 ();
if (!path_list && argc < 1)
dieusage (1);
if (aa_init_repo (path_repo, (mode & AA_MODE_IS_DRY) ? AA_REPO_READ : AA_REPO_WRITE) < 0)
aa_strerr_diefu2sys (ERR_IO, "init repository ", path_repo);
if (path_list)
{
stralloc sa = STRALLOC_ZERO;
int r;
if (*path_list != '/' && *path_list != '.')
stralloc_cats (&sa, LISTDIR_PREFIX);
stralloc_catb (&sa, path_list, strlen (path_list) + 1);
r = aa_scan_dir (&sa, 1, it_start, NULL);
stralloc_free (&sa);
if (r < 0)
aa_strerr_diefu3sys (-r, "read list directory ",
(*path_list != '/' && *path_list != '.') ? LISTDIR_PREFIX : path_list,
(*path_list != '/' && *path_list != '.') ? path_list : "");
}
tain_now_g ();
for (i = 0; i < argc; ++i)
if (str_equal (argv[i], "-"))
{
if (process_names_from_stdin ((names_cb) add_service, NULL) < 0)
aa_strerr_diefu1sys (ERR_IO, "process names from stdin");
}
else
add_service (argv[i], NULL);
mainloop (mode, scan_cb);
if (!(mode & AA_MODE_IS_DRY))
{
aa_bs_noflush (AA_OUT, "\n");
put_title (1, PROG, "Completed.", 1);
aa_show_stat_nb (nb_already, "Already up", ANSI_HIGHLIGHT_GREEN_ON);
aa_show_stat_nb (nb_done, "Started", ANSI_HIGHLIGHT_GREEN_ON);
show_stat_service_names (&ga_timedout, "Timed out", ANSI_HIGHLIGHT_RED_ON);
show_stat_service_names (&ga_failed, "Failed", ANSI_HIGHLIGHT_RED_ON);
show_stat_service_names (&ga_depend, "Dependency failed", ANSI_HIGHLIGHT_RED_ON);
aa_show_stat_names (aa_names.s, &ga_io, "I/O error", ANSI_HIGHLIGHT_RED_ON);
aa_show_stat_names (aa_names.s, &ga_unknown, "Unknown", ANSI_HIGHLIGHT_RED_ON);
aa_show_stat_names (aa_names.s, &ga_skipped, "Skipped", ANSI_HIGHLIGHT_YELLOW_ON);
}
genalloc_free (int, &ga_timedout);
genalloc_free (int, &ga_failed);
genalloc_free (int, &ga_depend);
genalloc_free (size_t, &ga_io);
genalloc_free (size_t, &ga_unknown);
genalloc_free (size_t, &ga_skipped);
genalloc_free (pid_t, &ga_pid);
genalloc_free (int, &aa_tmp_list);
genalloc_free (int, &aa_main_list);
stralloc_free (&aa_names);
genalloc_deepfree (struct progress, &ga_progress, free_progress);
aa_free_services (close_fd);
genalloc_free (iopause_fd, &ga_iop);
return rc;
}
lio_service_manager_t *lio_exnode_service_set_create()
{
lio_service_manager_t *ess;
ess = create_service_manager();
//** Install the drivers
add_service(ess, SEG_SM_LOAD, SEGMENT_TYPE_LINEAR, segment_linear_load);
add_service(ess, SEG_SM_CREATE, SEGMENT_TYPE_LINEAR, segment_linear_create);
add_service(ess, SEG_SM_LOAD, SEGMENT_TYPE_FILE, segment_file_load);
add_service(ess, SEG_SM_CREATE, SEGMENT_TYPE_FILE, segment_file_create);
add_service(ess, SEG_SM_LOAD, SEGMENT_TYPE_CACHE, segment_cache_load);
add_service(ess, SEG_SM_CREATE, SEGMENT_TYPE_CACHE, segment_cache_create);
add_service(ess, SEG_SM_LOAD, SEGMENT_TYPE_LUN, segment_lun_load);
add_service(ess, SEG_SM_CREATE, SEGMENT_TYPE_LUN, segment_lun_create);
add_service(ess, SEG_SM_LOAD, SEGMENT_TYPE_JERASURE, segment_jerasure_load);
add_service(ess, SEG_SM_CREATE, SEGMENT_TYPE_JERASURE, segment_jerasure_create);
add_service(ess, SEG_SM_LOAD, SEGMENT_TYPE_LOG, segment_log_load);
add_service(ess, SEG_SM_CREATE, SEGMENT_TYPE_LOG, segment_log_create);
add_service(ess, RS_SM_AVAILABLE, RS_TYPE_SIMPLE, rs_simple_create);
add_service(ess, RS_SM_AVAILABLE, RS_TYPE_REMOTE_CLIENT, rs_remote_client_create);
add_service(ess, RS_SM_AVAILABLE, RS_TYPE_REMOTE_SERVER, rs_remote_server_create);
add_service(ess, DS_SM_AVAILABLE, DS_TYPE_IBP, ds_ibp_create);
add_service(ess, OS_AVAILABLE, OS_TYPE_FILE, object_service_file_create);
add_service(ess, OS_AVAILABLE, OS_TYPE_REMOTE_CLIENT, object_service_remote_client_create);
add_service(ess, OS_AVAILABLE, OS_TYPE_REMOTE_SERVER, object_service_remote_server_create);
add_service(ess, OS_AVAILABLE, OS_TYPE_TIMECACHE, object_service_timecache_create);
add_service(ess, AUTHN_AVAILABLE, AUTHN_TYPE_FAKE, authn_fake_create);
add_service(ess, OSAZ_AVAILABLE, OSAZ_TYPE_FAKE, osaz_fake_create);
add_service(ess, CACHE_LOAD_AVAILABLE, CACHE_TYPE_AMP, amp_cache_load);
add_service(ess, CACHE_CREATE_AVAILABLE, CACHE_TYPE_AMP, amp_cache_create);
add_service(ess, CACHE_LOAD_AVAILABLE, CACHE_TYPE_ROUND_ROBIN, round_robin_cache_load);
add_service(ess, CACHE_CREATE_AVAILABLE, CACHE_TYPE_ROUND_ROBIN, round_robin_cache_create);
return(ess);
}
void _um_mod_init(char *initargs)
{
const char *name;
char *tmphs, *cwd;
int i;
PyObject *pName, *pTmpObj, *pTmpFunc, *pTmpDict;
GMESSAGE("umpyew init");
if (!strlen(initargs))
{
GERROR("You must specify the Python module name.");
return;
}
name = initargs;
s.name="Prototypal Python bindings for *MView";
s.code=0x07;
s.syscall=(sysfun *)calloc(scmap_scmapsize,sizeof(sysfun));
s.socket=(sysfun *)calloc(scmap_sockmapsize,sizeof(sysfun));
Py_Initialize();
Py_InitModule("umpyew", pEmbMethods);
pEmptyTuple = PyTuple_New(0);
pName = PyString_FromString(name);
cwd = getcwd(NULL, 0);
if (cwd)
{
setenv("PYTHONPATH", cwd, 0);
free(cwd);
}
pModule = PyImport_Import(pName);
Py_DECREF(pName);
if (!pModule)
{
GERROR("Error loading Python module %s.\nIt has been searched for in the following path:\n%s", name, getenv("PYTHONPATH"));
PyErr_Print();
return;
}
/*
* Add ctl
*/
if ((ps.ctl = PyObject_GetAttrString(pModule, "modCtl")) && PyCallable_Check(ps.ctl))
s.ctl = ctl;
else
{
GDEBUG(2, "function modCheckFun not defined in module %s", name);
s.ctl = umpyew_alwayszero;
Py_XDECREF(ps.ctl);
}
/*
* Add checkfun
*/
if ((ps.checkfun = PyObject_GetAttrString(pModule, "modCheckFun")) && PyCallable_Check(ps.checkfun))
s.checkfun = checkfun;
else
{
GDEBUG("2, function modCheckFun not defined in module %s", name);
/* This makes the module almost useless, but we respect its author's will. */
s.checkfun = (epoch_t(*)())umpyew_alwayszero;
Py_XDECREF(ps.checkfun);
}
/*
* Add ctlhs
*/
MCH_ZERO(&(s.ctlhs));
pTmpObj = PyObject_GetAttrString(pModule, "modCtlHistorySet");
if (pTmpObj && PyList_Check(pTmpObj))
for (i = 0; i < PyList_Size(pTmpObj); i++)
if ((tmphs = PyString_AsString(PyList_GET_ITEM(pTmpObj, i))))
{
if (!strcmp(tmphs, "proc"))
MCH_SET(MC_PROC, &(s.ctlhs));
else if (!strcmp(tmphs, "module"))
MCH_SET(MC_MODULE, &(s.ctlhs));
else if (!strcmp(tmphs, "mount"))
MCH_SET(MC_MOUNT, &(s.ctlhs));
}
Py_XDECREF(pTmpObj);
/*
* Call modInit, if present
*/
pTmpObj = PyObject_GetAttrString(pModule, "modInit");
if (pTmpObj && PyCallable_Check(pTmpObj))
PyObject_CallObject(pTmpObj, pEmptyTuple);
Py_XDECREF(pTmpObj);
/*
* Add system calls
*/
ps.syscall = calloc(scmap_scmapsize, sizeof(PyObject*));
PYTHON_SYSCALL(open, sysOpen);
PYTHON_SYSCALL(close, sysClose);
PYTHON_SYSCALL(access, sysAccess);
PYTHON_SYSCALL(mkdir, sysMkdir);
PYTHON_SYSCALL(rmdir, sysRmdir);
PYTHON_SYSCALL(chmod, sysChmod);
PYTHON_SYSCALL(chown, sysChown);
PYTHON_SYSCALL(lchown, sysLchown);
PYTHON_SYSCALL(unlink, sysUnlink);
PYTHON_SYSCALL(link, sysLink);
PYTHON_SYSCALL(symlink, sysSymlink);
PYTHON_SYSCALL(stat64, sysStat64);
PYTHON_SYSCALL(lstat64, sysLstat64);
PYTHON_SYSCALL(fstat64, sysFstat64);
PYTHON_SYSCALL(statfs64, sysStatfs64);
PYTHON_SYSCALL(fstatfs64, sysStatfs64);
PYTHON_SYSCALL(readlink, sysReadlink);
PYTHON_SYSCALL(lseek, sysLseek);
PYTHON_SYSCALL(utime, sysUtime);
PYTHON_SYSCALL(utimes, sysUtimes)
PYTHON_SYSCALL(read, sysRead);
PYTHON_SYSCALL(write, sysWrite);
PYTHON_SYSCALL(pread64, sysPread64);
PYTHON_SYSCALL(pwrite64, sysPwrite64);
add_service(&s);
}
