Project

General

Profile

Statistics
| Revision:

root / trunk / code / projects / colonet / ColonetServer / ColonetServer.cpp @ 469

History | View | Annotate | Download (6.77 KB)

1
/**
2
 * @file ColonetServer.cpp
3
 *
4
 * @brief colonet_server - primary server application for Colonet
5
 *
6
 * @author Jason Knichel
7
 * @author Eugene Marinelli
8
 * @date 10/31/06
9
 */
10

    
11
#include <arpa/inet.h>
12
#include <fcntl.h>
13
#include <errno.h>
14
#include <netinet/in.h>
15
#include <string.h>
16
#include <unistd.h>
17
#include <sys/select.h>
18
#include <sys/socket.h>
19

    
20
#include <colonet_wireless.h>
21

    
22
#include <ColonetServer.h>
23
#include <ConnectionPool.h>
24
#include <options.h>
25
#include <Log.h>
26

    
27
#define LISTEN_BACKLOG 5
28
#define LOG_BUFFER_LENGTH 128
29
#define MAX_MSG_BUFFER_LENGTH 128
30

    
31
#define u_int32_t unsigned
32

    
33
//TODO: is this needed anymore?  it still compiles when i comment it out
34
//static ConnectionPool* connection_pool;
35

    
36
/**
37
 * @brief Default constructor for ColonetServer
38
 */
39
ColonetServer::ColonetServer() {
40
  listen_socket = 0;
41
  connection_pool = new ConnectionPool(this);
42
}
43

    
44
/**
45
 * @brief Destructor for ColonetServer
46
 */
47
ColonetServer::~ColonetServer() {
48
}
49

    
50
/**
51
 * @brief Initializes the various elements needed for the server to run
52
 *
53
 * @param argc The number of command line arguments passed to the program
54
 * @param argv The command line arguments passed to the program
55
 *
56
 * @return 0 on success, negative error code on failure
57
 */
58
int ColonetServer::initialize_server(int argc, char * argv[]) {
59
  options_parseCmdLine(argc, argv);
60

    
61
  if (optionsG.logging_enabled) {
62
    logger = new Log("colonet_server_log.txt");
63
  }
64

    
65
  if (initialize_connection(optionsG.listen_port) < 0) {
66
    return -1;
67
  }
68

    
69
  if (initialize_wireless() < 0) {
70
    fprintf(stderr, "%s: initWireless failed\n", __FUNCTION__);
71
    return -1;
72
  }
73

    
74
  return 0;
75
}
76

    
77
/**
78
 * @brief Starts the server listening on the socket that was opened for listening
79
 *
80
 * @return 0 on success, negative error code on failure
81
 */
82
int ColonetServer::start_listening() {
83
  if (listen(listen_socket, LISTEN_BACKLOG) < 0) {
84
    if (optionsG.logging_enabled) {
85
      logger->log_error("\t\nThere was an error telling the socket to listen for connections from clients.  "
86
                        "Terminating Server...\n");
87
    }
88
    return -1;
89
  }
90

    
91
  return 0;
92
}
93

    
94
/**
95
 * @brief Starts the server running (starts an infinite loop)
96
 */
97
int ColonetServer::run_server() {
98
  connection_pool->add_new_socket_to_pool(listen_socket);
99

    
100
  int accept_socket = 0;
101
  struct sockaddr_in client_addr;
102
  socklen_t client_addr_size = sizeof(client_addr);
103

    
104
  if (optionsG.logging_enabled) {
105
    logger->log_message("Server initialized.  About to start listening for connections");
106
  }
107

    
108
  while(1) {
109
    usleep(10000);
110

    
111
    connection_pool->perform_select(listen_socket);
112

    
113
    //either no descriptors are ready or there was an error
114
    if (connection_pool->get_number_clients_ready() <= 0) {
115
      continue;
116
    }
117

    
118
    if (connection_pool->is_socket_ready_to_read(listen_socket)) {
119
      printf("Something is trying to connect...\n");
120
      if ((accept_socket = accept(listen_socket, (struct sockaddr*) &client_addr, &client_addr_size)) < 0) {
121
        if (errno == EMFILE) {
122
          printf("\tWhen attempting to accept a connection, reached the per process limit of file descriptors."
123
            "  Dropping the new connection.\n");
124
          continue;
125
        } else {
126
          printf("\tThere was an error when attempting to accept a connection");
127
        }
128
        continue;
129
      }
130

    
131
      if (optionsG.logging_enabled) {
132
        char log_buffer[LOG_BUFFER_LENGTH];
133
        snprintf(log_buffer, LOG_BUFFER_LENGTH, "Client at address %s attempting to connect.",
134
          inet_ntoa(client_addr.sin_addr));
135
        logger->log_string(LOG_TYPE_CONNECT, log_buffer);
136
      }
137

    
138
      if (connection_pool->add_client(accept_socket) < 0) {
139
        printf("\tThere was an error when trying to add a client to the connection pool.");
140
        continue;
141
      }
142

    
143
      if (optionsG.logging_enabled) {
144
        char log_buffer[LOG_BUFFER_LENGTH];
145
        snprintf(log_buffer, LOG_BUFFER_LENGTH, "Client at address %s successfully added to connection pool.",
146
                 inet_ntoa(client_addr.sin_addr));
147
        logger->log_string(LOG_TYPE_CONNECT, log_buffer);
148
      }
149
    }
150

    
151
    if (connection_pool->check_clients() < 0) {
152
      printf("\tThere was an error trying to update the clients.");
153
      continue;
154
    }
155
  }
156

    
157
  return 0;
158
}
159

    
160
/**
161
* @param source - ID of robot that message is from.
162
* @param dest - ID of internet client to send message to.
163
* @param data - Data to send to internet client.
164
* @param len - Length of the data param.
165
*/
166
int ColonetServer::process_received_wireless_message(int dest, char* data, int len) {
167
  if (connection_pool->write_to_client(dest, data, len) == ERROR_INVALID_CLIENT_ID) {
168
    printf("The robot wanted to pass the data to a client not in the pool.\n");
169
    return -1;
170
  }
171

    
172
  return 0;
173
}
174

    
175
/**
176
 * @brief Initializes the wireless
177
 *
178
 * @return 0 on success, negative error code on error
179
 */
180
int ColonetServer::initialize_wireless() {
181
  char* log_filename = NULL;
182

    
183
  if (optionsG.logging_enabled) {
184
    printf("Logging enabled. Log filename: %s\n", optionsG.log_filename);
185
    log_filename = optionsG.log_filename;
186
  } else {
187
    printf("Logging disabled.\n");
188
  }
189

    
190
  if (colonet_wl_init(optionsG.wireless_port, log_filename) != 0) {
191
    fprintf(stderr, "ERROR - colonet_wl_init failed.\n");
192
    return -1;
193
  }
194

    
195
  if (colonet_wl_run_listener_thread()) {
196
    fprintf(stderr, "%s: colonet_wl_run_listener_thread failed.\n", __FUNCTION__);
197
    return -1;
198
  }
199

    
200
  return 0;
201
}
202

    
203
/**
204
 * @brief Initialize a connection to listen on
205
 *
206
 * @port The port to try to open to listen on
207
 *
208
 * @return 0 on success, negative error code on error
209
 */
210
int ColonetServer::initialize_connection(int port) {
211
  printf("Initializing connection that will be used to listen for clients...\n");
212
  int options = 1;
213
  struct sockaddr_in my_address;
214

    
215
  //get a socket fd
216
  if ((listen_socket = socket(AF_INET, SOCK_STREAM, 0)) < 0) {
217
    printf("\tThere was an error creating socket\n");
218
    return -1;
219
  }
220

    
221
  //set up the address struct
222
  memset(&my_address,'\0',sizeof(my_address));
223
  my_address.sin_family = AF_INET;
224
  my_address.sin_addr.s_addr = htonl(INADDR_ANY);
225
  my_address.sin_port = htons(port);
226

    
227
  setsockopt(listen_socket, SOL_SOCKET, SO_REUSEADDR, &options, sizeof(options));
228

    
229
  //get the current socket options
230
  if ((options = fcntl(listen_socket, F_GETFL)) < 0) {
231
    printf("\tThere was an error getting the socket options.\n");
232
    return -1;
233
  }
234

    
235
  //set the socket to non blocking
236
  options = (options | O_NONBLOCK);
237
  if (fcntl(listen_socket, F_SETFL, options) < 0) {
238
    printf("\tThere was an error setting the socket to be non blocking.\n");
239
    return -1;
240
  }
241

    
242
  //bind the socket to listen on the specified port
243
  if (bind(listen_socket, (struct sockaddr *) &my_address, sizeof(my_address)) < 0) {
244
    printf("\tThere was an error binding the socket\n");
245
    return -1;
246
  }
247

    
248
  return 0;
249
}
250

    
251
PositionMonitor* ColonetServer::getPositionMonitor() {
252
  return &position_monitor;
253
}