Example #1
0
File: rtp.c Project: viettd56/SA
int rtp_setup(SOCKADDR *remote, int cport, int tport) {
    if (running)
        die("rtp_setup called with active stream!");

    debug(1, "rtp_setup: cport=%d tport=%d\n", cport, tport);

    // we do our own timing and ignore the timing port.
    // an audio perfectionist may wish to learn the protocol.

    memcpy(&rtp_client, remote, sizeof(rtp_client));
#ifdef AF_INET6
    if (rtp_client.SAFAMILY == AF_INET6) {
        struct sockaddr_in6 *sa6 = (struct sockaddr_in6*)&rtp_client;
        sa6->sin6_port = htons(cport);
    } else
#endif
    {
        struct sockaddr_in *sa = (struct sockaddr_in*)&rtp_client;
        sa->sin_port = htons(cport);
    }

    int sport = bind_port(remote);

    debug(1, "rtp listening on port %d\n", sport);

    please_shutdown = 0;
    pthread_create(&rtp_thread, NULL, &rtp_receiver, NULL);

    running = 1;
    return sport;
}
Example #2
0
static err_t idc_bind_port(uint16_t port, net_ports_port_type_t port_type)
{
    if (is_owner) {
        LWIPBF_DEBUG("idc_bind_port: called by owner\n");
        return bind_port(port, port_type);
    }

    LWIPBF_DEBUG("idc_bind_port: called\n");

    errval_t err, msgerr;

    /* getting the proper buffer id's here */
    err = net_ports_rpc.vtbl.bind_port(&net_ports_rpc, port_type, port,
                                  /* buffer for RX */
                                  ((struct client_closure_NC *)
                                   driver_connection[RECEIVE_CONNECTION]->st)->
                                  buff_ptr->buffer_id,
                                  /* buffer for TX */
                                  ((struct client_closure_NC *)
                                   driver_connection[TRANSMIT_CONNECTION]->st)->
                                  buff_ptr->buffer_id,
                                  appid_delete, qid_delete,
                                  &msgerr);
    if (err_is_fail(err)) {
        USER_PANIC_ERR(err, "error sending get_ip_info");
    }

    LWIPBF_DEBUG("idc_new_tcp_port: terminated\n");

    if (msgerr == PORT_ERR_IN_USE) {
        return ERR_USE;
    }                           // FIXME: other errors?
    return ERR_OK;
}
Example #3
0
static
void run_recv()
{
    int sock;
    int ret;
    char *buf;

    printf("Start server on port %d. My PSID: %d\n",
	   arg_serverport, PSP_GetNodeID());
    sock = socket(PF_P4S , 0, 0);
    if (!sock) goto err_socket;

    ret = bind_port(sock, arg_serverport);
    if (ret) goto err_bind;

    buf = (char*)malloc(SERVER_BUFLEN);
    if (!buf) goto err_malloc;

    while (1) {
	uint16_t src;
	int len;
	len = sock_recv(sock, &src, buf, SERVER_BUFLEN);
	if (arg_verbose > 0) {
	    printf("Recv %d bytes from %d\n",len ,src);
	    if ((arg_verbose > 1) && (len > 0)) {
		if (arg_verbose > 2) {
		    dump(buf, 0, len, 0, 16, "recv");
		} else {
		    printf(":%s:\n", dumpstr(buf, MIN(len,32)));
		}
	    }
	}
    }

    return;
 err_socket:
    perror("socket()");
    exit(1);
 err_bind:
    perror("bind()");
    exit(1);
 err_malloc:
    perror("malloc()");
    exit(1);
}
Example #4
0
int main (int argc, char * argv[]) {
    /* availability options */
    char * opts = "d";
    /* processed option */
    int c;

    int sock_id;

    /* dodanie handlera na SIGINT */
    signal(SIGINT, sigint_handler);

    /* check if define more than one option */
    if (argc == 2) {
        /* iteration by each of option */
        while ((c = getopt(argc, argv, opts)) != -1) {
            switch (c) {
                /* for 'u' run daemon */
                case 'd':
                    create_daemon();
                    break;
                /* for unrecognized option */
                case '?':
                default:
                    printf("Ignore passed options\n");
            }
        }
    }

    printf("=== create server ===\n\n");

    /* create socket */
    sock_id = create_socket_tcp();

    /* bind server to defined port */
    bind_port(sock_id, PORT);

    /* server waiting for client */
    listen_for_client_tcp(sock_id, MAX_QUEUE);

    /* handle client */
    handle_incoming_client(sock_id, send_time_to_socket, 1);

    return 0;
}
Example #5
0
URI& URI::parse() {
  http_parser_url u;
  http_parser_url_init(&u);

  const auto p = uri_str_.data();
  const auto result = http_parser_parse_url(p, uri_str_.size(), 0, &u);

#ifdef URI_THROW_ON_ERROR
  if (result not_eq 0) {
    std::string uri{uri_str_.begin(), uri_str_.end()};
    throw URI_error{"Invalid uri: " + uri};
  }
#endif //< URI_THROW_ON_ERROR

  (void)result;

  scheme_   = (u.field_set & (1 << UF_SCHEMA))   ? util::sview{p + u.field_data[UF_SCHEMA].off,   u.field_data[UF_SCHEMA].len}   : util::sview{};
  userinfo_ = (u.field_set & (1 << UF_USERINFO)) ? util::sview{p + u.field_data[UF_USERINFO].off, u.field_data[UF_USERINFO].len} : util::sview{};
  host_     = (u.field_set & (1 << UF_HOST))     ? util::sview{p + u.field_data[UF_HOST].off,     u.field_data[UF_HOST].len}     : util::sview{};
  path_     = (u.field_set & (1 << UF_PATH))     ? util::sview{p + u.field_data[UF_PATH].off,     u.field_data[UF_PATH].len}     : util::sview{};
  query_    = (u.field_set & (1 << UF_QUERY))    ? util::sview{p + u.field_data[UF_QUERY].off,    u.field_data[UF_QUERY].len}    : util::sview{};
  fragment_ = (u.field_set & (1 << UF_FRAGMENT)) ? util::sview{p + u.field_data[UF_FRAGMENT].off, u.field_data[UF_FRAGMENT].len} : util::sview{};

  auto port_str_ = (u.field_set & (1 << UF_PORT)) ?
    util::sview{p + u.field_data[UF_PORT].off, u.field_data[UF_PORT].len} : util::sview{};

  if(not port_str_.empty())
  {
    std::array<char, 32> buf;
    std::copy(port_str_.begin(), port_str_.end(), buf.begin());
    buf[port_str_.size()] = 0;
    port_ = std::atoi(buf.data());
  }
  else
  {
    port_ = bind_port(scheme_, u.port);
  }


  return *this;
}
Example #6
0
void* client(void *arg)
{
  char request[1024];
  int sock, ret, i, len;
  cpu_tick_t start, end;
  int server_num = (int) arg;
  int did_some_io = 1;
  int optval;


  // loop, making requests, & keeping stats
  while( 1 ) {
    state_idle++;
  

    // yield, if we didn't yet, ie, due to socket() or connect() failures
    if( !did_some_io )
      sched_yield();
    did_some_io = 0;


    state_idle--; 
    state_connecting++;

    // new socket
    sock = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
    if( sock == -1 ) { 
      if( debug ) printf("client() - error with socket(): %s\n", strerror(errno));
      io_errors++;  //perror("socket"); 
      state_connecting--;
      continue; 
    }

    // turn off TCP linger, to do a quick close of the socket
    if ( 0 ) {
      struct linger linger;
      linger.l_onoff = 1;
      linger.l_linger = 0;
      if (setsockopt (sock, SOL_SOCKET, SO_LINGER, &linger, sizeof (linger)) < 0) {
        if( debug ) printf("client() - error setting SO_LINGER: %s\n", strerror(errno));
        io_errors++;
        state_connecting--;
        continue;
      }
    }


    // make the sockets reusable, so we don't wait as long for the
    // kernel to clean things up, and hence run out of sockets.
    //
    // FIXME: is this only meaningful for server sockets??
    optval = 1;
    if (setsockopt(sock, SOL_SOCKET, SO_REUSEADDR, &optval, sizeof(optval)) < 0) {
      if( debug ) printf("client() - error setting SO_REUSEADDR: %s\n", strerror(errno));
      io_errors++;
      state_connecting--;
      continue;
    }

    /*
    optval = SEND_BUFFER_SIZE;
    if (setsockopt (sock, SOL_SOCKET, SO_SNDBUF, &optval, sizeof (optval)) < 0)
    {
      if( debug ) printf("client() - error setting SO_SNDBUF: %s\n", strerror(errno));
      io_errors++;
      state_connecting--;
      continue;
    }
    
    optval = RECV_BUFFER_SIZE;
    if (setsockopt (sock, SOL_SOCKET, SO_RCVBUF, &optval, sizeof (optval)) < 0)
    {
      if( debug ) printf("client() - error setting SO_RCVBUF: %s\n", strerror(errno));
      io_errors++;
      state_connecting--;
      continue;
    }
    */

    // Disable the Nagle algorithm so the kernel won't delay our
    // writes waiting for more data.
    if( 1 ) {
      optval = 1;
      //if (setsockopt (sock, IPPROTO_TCP, TCP_NODELAY, &optval, sizeof (optval)) < 0)
      if (setsockopt (sock, SOL_TCP, TCP_NODELAY, &optval, sizeof (optval)) < 0)
      {
        if( debug ) printf("client() - error setting TCP_NODELAY: %s\n", strerror(errno));
        io_errors++;
        state_connecting--;
        continue;
      }
    }

    if ( !bind_port(sock) ) {
      state_connecting--;
      continue;
    }

    // Disable the Nagle algorithm so the kernel won't delay our
    // writes waiting for more data.
    if( 1 ) {
      optval = 1;
      //if (setsockopt (sock, IPPROTO_TCP, TCP_NODELAY, &optval, sizeof (optval)) < 0)
      if (setsockopt (sock, SOL_TCP, TCP_NODELAY, &optval, sizeof (optval)) < 0)
      {
        if( debug ) printf("client() - error setting TCP_NODELAY: %s\n", strerror(errno));
        io_errors++;
        state_connecting--;
        continue;
      }
    }

    // connect
    //output("connecting...\n");
    server_num++; server_num = server_num % num_servers;
    GET_REAL_CPU_TICKS(start);
    ret = connect(sock, (struct sockaddr *)&servers[server_num].addr, sizeof(servers[0].addr));
    GET_REAL_CPU_TICKS(end);
    if( ret < 0 ) { 
      state_connecting--; 
      hist_add(err_connect_hist, HIST_INTERVAL(start,end));

      if( errno == EADDRNOTAVAIL ) {
        addrnotavail++;
      } else {
        io_errors++; 
        if( debug )
          printf("client() - error with connect(): %s\n", strerror(errno));
      }

      GET_REAL_CPU_TICKS(start);
      state_closing++;
      close(sock);
      state_closing--;
      GET_REAL_CPU_TICKS(end);
      hist_add(close_unconnected_hist, HIST_INTERVAL(start,end));

      continue; 
    }
    hist_add(connect_hist, HIST_INTERVAL(start,end));


    // Disable the Nagle algorithm so the kernel won't delay our
    // writes waiting for more data.
    if( 1 ) {
      optval = 1;
      //if (setsockopt (sock, IPPROTO_TCP, TCP_NODELAY, &optval, sizeof (optval)) < 0)
      if (setsockopt (sock, SOL_TCP, TCP_NODELAY, &optval, sizeof (optval)) < 0)
      {
        if( debug ) printf("client() - error setting TCP_NODELAY: %s\n", strerror(errno));
        io_errors++;
        state_connecting--;
        continue;
      }
    }

    state_connecting--;

    // issue requests
    for( i=0; i<nreqs; i++ ) {
      len = snprintf(request, sizeof(request)-1, 
                     "GET /%s/dir%05d/class%d_%d HTTP/1.1\r\n"
                     "Host: %s\r\n"
                     //"User-Agent: Mozilla/4.0 (compatible; MSIE 4.01; windows 98)\r\n"
                     //"Accept: */*\r\n"
                     //"Accept-Encoding: gzip, deflate\r\n"
                     //"Accept-Language: en/us\r\n"
                     //"Connection: Close\r\n"
                     "\r\n", 
                     servers[server_num].url, spec_dir(), spec_class(), spec_file(),
                     servers[server_num].hostname
                     );
      assert(len > 0);

      // note that we did some IO, so this thread has already yielded.
      did_some_io = 1;

      state_writing++;
      GET_REAL_CPU_TICKS(start);
      ret = write( sock, request, len );
      GET_REAL_CPU_TICKS(end);
      hist_add(request_hist, HIST_INTERVAL(start,end));
      state_writing--;

      // we do this here, instead of after connect b/c w/ Capriccio
      // the connect() call seems to always return immediately.
      good_conn++;

      if( len != ret ) {
        // FIXME: for now, don't add anything to the response hist, if we get a failure here
        if( errno == ETIMEDOUT ) {
          conn_timedout++;
        } else {
          if(debug) 
            printf("client() - error writing request: %s\n", strerror(errno));
          io_errors++;
        }
        break;
      }

        //output("reading response...\n");
      state_reading++;
      GET_REAL_CPU_TICKS(start);
      if( read_response( sock ) == 0 )
        requests_completed++;
      else 
        bad_conn++;
      GET_REAL_CPU_TICKS(end);
      hist_add(response_hist, HIST_INTERVAL(start,end));
      state_reading--;
      // FIXME: close the connection on errors?


      // sleep for a second
      if(i < nreqs-1 && sleep_ms > 0) {
        state_idle++;
        GET_REAL_CPU_TICKS(start);
        usleep(sleep_ms*1000);
        GET_REAL_CPU_TICKS(end);
        hist_add(sleep_hist, HIST_INTERVAL(start,end));
        state_idle--;
      }

    }

    //output("closing...\n");
    state_closing++;
    GET_REAL_CPU_TICKS(start);
    close( sock );
    GET_REAL_CPU_TICKS(end);
    hist_add(close_hist, HIST_INTERVAL(start,end));
    state_closing--;
  }

  return NULL;
}
Example #7
0
int
main(int argc, char **argv)
{
    /* arguments */
    int c;
    int port = DEFAULT_PORT;
    const char* datafile;
    int forknum = 0;

    /* network */
    int fam = AF_INET;
    bool random_port_success;

#ifdef USE_WINSOCK
    WSADATA wsa_data;
#endif

    /* parse arguments */
    srandom(time(NULL) ^ getpid());
    logfile = stdout;
    prog_name = argv[0];
    log_msg("%s: start\n", prog_name);
    while((c = getopt(argc, argv, "6f:p:rv")) != -1) {
        switch(c) {
        case '6':
#ifdef AF_INET6
            fam = AF_INET6;
#else
            log_msg("cannot -6: no IP6 available\n");
            exit(1);
#endif
            break;
        case 'r':
            port = 0;
            break;
        case 'f':
            forknum = atoi(optarg);
            if(forknum < 1)
                error("invalid forkno %s, give number", optarg);
            break;
        case 'p':
            port = atoi(optarg);
            if (port < 1) {
                error("Invalid port %s, use a number.", optarg);
            }
            break;
        case 'v':
            do_verbose++;
            break;
        default:
            usage();
            break;
        }
    }
    argc -= optind;
    argv += optind;

    if(argc == 0 || argc > 1)
        usage();

    datafile = argv[0];
    log_msg("Reading datafile %s\n", datafile);
    entries = read_datafile(datafile, 0);

#ifdef USE_WINSOCK
    if(WSAStartup(MAKEWORD(2,2), &wsa_data) != 0)
        error("WSAStartup failed\n");
#endif

    if((udp_sock = socket(fam, SOCK_DGRAM, 0)) < 0) {
        error("udp socket(): %s\n", strerror(errno));
    }
    if((tcp_sock = socket(fam, SOCK_STREAM, 0)) < 0) {
        error("tcp socket(): %s\n", strerror(errno));
    }
    c = 1;
    if(setsockopt(tcp_sock, SOL_SOCKET, SO_REUSEADDR, (void*)&c, (socklen_t) sizeof(int)) < 0) {
        error("setsockopt(SO_REUSEADDR): %s\n", strerror(errno));
    }

    /* bind ip4 */
    if (port > 0) {
        if (bind_port(udp_sock, port, fam)) {
            error("cannot bind(): %s\n", strerror(errno));
        }
        if (bind_port(tcp_sock, port, fam)) {
            error("cannot bind(): %s\n", strerror(errno));
        }
        if (listen(tcp_sock, CONN_BACKLOG) < 0) {
            error("listen(): %s\n", strerror(errno));
        }
    } else {
        random_port_success = false;
        while (!random_port_success) {
            port = (random() % 64510) + 1025;
            log_msg("trying to bind to port %d\n", port);
            random_port_success = true;
            if (bind_port(udp_sock, port, fam)) {
#ifdef EADDRINUSE
                if (errno != EADDRINUSE) {
#elif defined(USE_WINSOCK)
                if (WSAGetLastError() != WSAEADDRINUSE) {
#else
                if (1) {
#endif
                    perror("bind()");
                    return -1;
                } else {
                    random_port_success = false;
                }
            }
            if (random_port_success) {
                if (bind_port(tcp_sock, port, fam)) {
#ifdef EADDRINUSE
                    if (errno != EADDRINUSE) {
#elif defined(USE_WINSOCK)
                    if (WSAGetLastError()!=WSAEADDRINUSE) {
#else
                    if (1) {
#endif
                        perror("bind()");
                        return -1;
                    } else {
                        random_port_success = false;
                    }
                }
            }
            if (random_port_success) {
                if (listen(tcp_sock, CONN_BACKLOG) < 0) {
                    error("listen(): %s\n", strerror(errno));
                }
            }

        }
    }
    log_msg("Listening on port %d\n", port);

    /* forky! */
    if(forknum > 0)
        forkit(forknum);

    service();

    return 0;
}
Example #8
0
static void daemon_login(int argc, char *argv[], char *envp[]) {
    int msock, csock;	/* socket for Master and Child */
    FILE *fp;
    int listen_port = 23;
    int len_of_sock_addr;
    char buf[256];

    /* setup standalone */

    start_daemon();

    signal_restart(SIGCHLD, reapchild);

    /* choose port */
    if(argc == 1)
	listen_port = 3006;
    else if(argc >= 2)
	listen_port = atoi(argv[1]);

    sprintf(margs, "%s %d ", argv[0],listen_port);

    /* port binding */
    xsin.sin_family = AF_INET;
    msock = bind_port(listen_port);
    if(msock<0) {
	syslog(LOG_INFO, "mbbsd bind_port failed.\n");
	exit(1);
    }
    
    initsetproctitle(argc, argv, envp);
    setproctitle("%s: listening ", margs);
    
    /* Give up root privileges: no way back from here */
    setgid(BBSGID);
    setuid(BBSUID);
    chdir(BBSHOME);
    
    /* mmap passwd file */
    if(passwd_mmap())
	exit(1);
    
    sprintf(buf, "/var/run/mbbsd.%d.pid", listen_port);
    if((fp = fopen(buf, "w"))) {
	fprintf(fp, "%d\n", getpid());
	fclose(fp);
    }
    
    /* main loop */
    for(;;) {

	len_of_sock_addr = sizeof(xsin);
	csock = accept(msock, (struct sockaddr *)&xsin, &len_of_sock_addr);

	if(csock < 0) {
	    if(errno!=EINTR) sleep(1);
	    continue;
	}
	
	if(check_ban_and_load(csock))
	{
	    close(csock);
	    continue;
	}
	
	if(fork()==0)
	    break;
	else
	    close(csock);
    }	

    /* here is only child running */
	
    close(msock);
    dup2(csock, 0);
    close(csock);

    getremotename(&xsin, fromhost, remoteusername);		/* RFC931 */

    /* ban 掉 bad host / bad user  shiuan88: 賣補帖的 */
    if(bad_host(fromhost) || strstr(fromhost, "bbs.") ||
       strstr(fromhost, "ccsun53.cc.ntu") ||
       !strcmp(remoteusername, "shiuan88")) {
	outs("\n     抱歉, 本站謝絕由此處來的user...\n");
	refresh();
	exit(1);
    }
    {
	char RFC931[80];
	    
	sprintf(RFC931, "%s@%s", remoteusername, fromhost);
	setenv("RFC931", RFC931, 1);
    }
    telnet_init();
	
    setproctitle("%s: ..login..", margs);
}
Example #9
0
static
void run_send()
{
    int sock;
    int ret;
    int conid;
    char *buf;
    int i;

    printf("Start client from port %d to port %d\n",
	   arg_clientport, arg_serverport);

    sock = socket( PF_P4S , 0, 0 );
    if (!sock) goto err_socket;

    ret = bind_port(sock, arg_clientport);
    if (ret) goto err_bind;

    buf = (char*)malloc(arg_size);
    if (!buf) goto err_malloc;

    for (i = 0; i < arg_size; i++) {
	buf[i] = i;
    }
    for (i = 0; i < arg_size; i++) {
	buf[i] = (i & ~3) >> (8*(3-(i & 3)));
    }
//    memset(buf, 0x42, arg_size);

    conid = connect_port(sock, arg_servernode, arg_serverport);
    if (conid < 0) goto err_connect;


    if (arg_verbose > 0) {
	printf("Connect to %08x:%d with id %d\n",
	       arg_servernode, arg_serverport, conid);
	printf("Send %d bytes\n",arg_size);

	if ((arg_verbose > 1) && (arg_size > 0)) {
	    if (arg_verbose > 2) {
		dump(buf, 0, arg_size, 0, 16, "send");
	    } else {
		printf(":%s:\n", dumpstr(buf, MIN(arg_size,32)));
	    }
	}
    }

    {
	uint16_t dest = conid;
	int len;
	int offset = 0;

	while (offset < arg_size) {
	    len = sock_send(sock, dest, buf + offset, arg_size - offset);
	    if (len < 0) {
		perror("send");
	    } else {
		if (arg_verbose > 1) {
		    printf("Send bytes %d - %d.\n",
			   offset, offset + len - 1);
		}
		offset += len;
	    }
	}
    }
//    sleep(10);
    free(buf);
    return;
 err_socket:
    perror("socket()");
    exit(1);
 err_bind:
    perror("bind()");
    exit(1);
 err_malloc:
    perror("malloc()");
    exit(1);
 err_connect:
    perror("connect()");
    exit(1);
}
Example #10
0
//
// visit_component
//
int Servant_Impl::visit_component (AST_Component * node)
{
  const ACE_CString context =
    ACE_CString (node->local_name ()->get_string ()) + "_Context";

  const ACE_CString servant =
    ACE_CString (node->local_name ()->get_string ()) + "_Servant";

  const char * local_name = node->local_name ()->get_string ();
  const char * flat_name = node->flat_name ();
  const char * full_name = node->full_name ();

  Provides_Svnt_Impl facet_servant (this->hfile_, this->sfile_, context);
  facet_servant.visit_scope (node);

  this->hfile_
    << "// Type definition of the servant base type." << std::endl
    << "typedef "
    << be_global->get_servant_template_typename ()
    << " < " << std::endl
    << "  " << servant << "," << std::endl
    << "  " << context << "," << std::endl
    << "  ::CIAO_" <<  flat_name << "_Impl::" << local_name << "_Exec," << std::endl
    << "  ::POA_" << full_name << " > " << servant << "_Base;"
    << std::endl
    << "class ";

  if (!be_global->svnt_export_macro_.empty ())
    this->hfile_ << be_global->svnt_export_macro_ << " ";

  this->hfile_
    << servant << std::endl
    << "  : public " << servant << "_Base"
    << "{";

  be_global->generate_class_preamble (node, this->hfile_, this->sfile_, servant);

  this->hfile_
    << "/// typedef for generated implementation code" << std::endl
    << "typedef " << servant << " self_type;" << std::endl
    << "/// Default constructor" << std::endl
    << "public:" << std::endl
    << servant << " (const char * name," << std::endl
    << "::PortableServer::POA_ptr poa," << std::endl
    << "::CIAO_" << flat_name << "_Impl::" << local_name << "_Exec_ptr executor);"
    << std::endl
    << "/// Destructor" << std::endl
    << "virtual ~" << servant << " (void);"
    << std::endl;

  this->sfile_
    << servant << "::" << std::endl
    << servant << " (const char * name," << std::endl
    << "::PortableServer::POA_ptr poa," << std::endl
    << "::CIAO_" << flat_name << "_Impl::" << local_name << "_Exec_ptr executor)" << std::endl
    << ": " <<  servant << "_Base (this, name, poa, executor)";

  if (be_global->uses_default_bmi (node))
  {
    Base_Member_Init bmi (this->sfile_, servant);
    bmi.visit_scope (node);
  }
  else
  {
    be_global->generate_custom_bmi (node, this->sfile_);
  }

  this->sfile_
    << "{";

  be_global->generate_constructor_preamble (node, this->sfile_);

  Bind_Port bind_port (this->sfile_, servant);
  bind_port.visit_scope (node);

  // Allow backend to generate any additionl initialization code
  be_global->generate_constructor_postamble (node, this->sfile_);

  this->sfile_
    << "}"
    << servant << "::~" << servant << " (void)"
    << "{"
    << "}";

  // Write the function for setting the implementations attribute
  // values via the configuration file.
  Set_Attributes set_attributes (this->hfile_, this->sfile_, servant);
  node->ast_accept (&set_attributes);

  // Write the remaining set of the methods that are based on the
  // names and types of defined ports.
  Subscribe_Method sm (this->hfile_, this->sfile_, servant);
  sm.visit_scope (node);

  if (be_global->uses_default_push_method (node))
  {
    Servant_Push_Method spm (this->hfile_, this->sfile_, servant);
    spm.visit_scope (node);
  }
  else
  {
    be_global->generate_custom_push_method (node, this->hfile_, this->sfile_, servant);
  }

  Get_Consumer_Method gcm (this->hfile_, this->sfile_, servant);
  gcm.visit_scope (node);

  Attribute_Method attr_method (this->hfile_, this->sfile_, servant);
  attr_method.visit_scope (node);

  Consumer_Variable consumer_variables (this->hfile_, servant);
  consumer_variables.visit_scope (node);

  be_global->generate_class_postamble (node, this->hfile_, this->sfile_, servant);

  // Factory method for the servant. This is a C-style function
  // that is exported from the binary.
  this->hfile_
    << "};";

  if (!be_global->svnt_export_macro_.empty ())
  {
    this->hfile_
      << "extern \"C\" " << be_global->svnt_export_macro_
      << " ::PortableServer::Servant" << std::endl
      << "create_" << flat_name << "_Servant (const char * name," << std::endl
      << "::PortableServer::POA_ptr poa," << std::endl
      << "::Components::EnterpriseComponent_ptr p);"
      << std::endl;

    this->sfile_
      << "::PortableServer::Servant" << std::endl
      << "create_" << flat_name << "_Servant (const char * name," << std::endl
      << "::PortableServer::POA_ptr poa," << std::endl
      << "::Components::EnterpriseComponent_ptr p)"
      << "{"
      << "return ::iCCM::create_servant <"
      << " CIAO_" << flat_name << "_Impl::" << local_name << "_Exec, "
      << servant << " > (name, poa, p);"
      << "}";
  }

  return 0;
}