int socket_initialize()
{
socket_loadbans();
if (socket_new(&srv_http, config->port_http))
return 1;
if (socket_new(&srv_https, config->port_https))
return 1;
pthread_create(&http_listener, 0, socket_http_listener, 0);
pthread_create(&https_listener, 0, socket_https_listener, 0);
//Initialize OpenSSL
char certpath[512];
char pkeypath[512];
snprintf(certpath, 512, CONF_DIR "/%s", config->ssl_cert);
snprintf(pkeypath, 512, CONF_DIR "/%s", config->ssl_pkey);
SSL_library_init();
OpenSSL_add_all_algorithms();
SSL_load_error_strings();
method = SSLv23_server_method();
ctx = SSL_CTX_new(method);
if (!ctx){
ERR_print_errors_fp(stderr);
return 1;
}
if (SSL_CTX_use_certificate_file(ctx, certpath, SSL_FILETYPE_PEM) <= 0){
ERR_print_errors_fp(stderr);
return 1;
}
if (SSL_CTX_use_PrivateKey_file(ctx, pkeypath, SSL_FILETYPE_PEM) <= 0){
ERR_print_errors_fp(stderr);
return 1;
}
if (!SSL_CTX_check_private_key(ctx)){
puts("Key does not match certificate");
return 1;
}
size_t num_locks = CRYPTO_num_locks();
openssl_locks = malloc(num_locks * sizeof(pthread_mutex_t));
for (unsigned i = 0; i < num_locks; i++){
pthread_mutex_init(&openssl_locks[i], 0);
}
CRYPTO_set_id_callback(openssl_id);
CRYPTO_set_locking_callback(openssl_lock);
return 0;
}
/** Create an IP Socket object bound to ADDR and PORT.
*
* This function binds the newly-created socket, but doesn't listen on it just yet.
*
* \param name name of the object, used for debugging
* \param port port used
* \param is_tcp true if TCP, false for UDP XXX: This should be more generic
* \return a pointer to the SocketInt object, cast as a Socket
*/
Socket*
socket_in_new(
char* name,
int port,
int is_tcp
) {
SocketInt* self;
if ((self = (SocketInt*)socket_new(name, is_tcp)) == NULL)
return NULL;
// o_log(O_LOG_DEBUG, "socket:%s: Attempt to join %s:%d\n", name, addr, port);
self->servAddr.sin_family = PF_INET;
self->servAddr.sin_port = htons(port);
self->servAddr.sin_addr.s_addr = htonl(INADDR_ANY);
if(bind(self->sockfd, (struct sockaddr *)&self->servAddr,
sizeof(struct sockaddr_in)) < 0) {
o_log(O_LOG_ERROR, "socket:%s: Error binding socket to interface: %s\n",
name, strerror(errno));
return NULL;
}
self->localport = ntohs(self->servAddr.sin_port);
o_log(O_LOG_DEBUG, "socket:%s: Socket bound to port: %d\n", name, self->localport);
self->next = instances;
instances = self;
return (Socket*)self;
}
int zsp_listener_start(zsp_listener_t *listener, int port)
{
if (listener == NULL || port <= 0)
return SSS_ERROR;
int is_ok = SSS_ERROR;
do
{
if (socket_new(&listener->sock, SOCKET_TCP_TYPE) == SSS_ERROR)
break;
if (thread_new(&listener->thread) == SSS_ERROR)
break;
listener->port = port;
if (socket_bind(listener->sock, port) == SSS_ERROR)
break;
if (socket_listen(listener->sock) == SSS_ERROR)
break;
thread_set_interval_time(listener->thread, 0);
if (thread_start(listener->thread, _zsp_listener_thread, listener) == SSS_ERROR)
break;
is_ok = SSS_OK;
} while (0);
if (is_ok == SSS_ERROR)
{
zsp_listener_stop(listener);
}
return is_ok;
}
Display *OpenDisplay(char *hostname, int port)
{
Display *display = NULL;
Socket *socket = NULL;
char *port_buf = NULL;
port_buf = int_to_string(port);
if (port_buf == NULL)
return NULL;
socket = socket_new(Socket_Blocking);
if (socket_connect(socket, hostname, port_buf) != 0) {
socket_free(socket);
free(port_buf);
return NULL;
}
free(port_buf);
display = (Display *) malloc(sizeof(Display));
display->socket = socket;
display->hostname = strdup(hostname);
display->port = port;
display->callbacks = callbacks_new();
return display;
}
/**
* Pass on to methods in http/cervlet.c to start/stop services
* @param P A service name as stated in the config file
* @param action A string describing the action to execute
*/
void d_check_service(const char *P, const char *action) {
Socket_T s;
char *auth= get_basic_authentication_header();
ASSERT(P);
ASSERT(action);
s= socket_new(Run.bind_addr?Run.bind_addr:"localhost",
Run.httpdport, SOCKET_TCP, Run.httpdssl);
if(!s) {
log("%s: Cannot connect to the monit daemon. "
"Did you start it with http support?\n", prog);
goto error;
} else {
socket_print(s, "GET /%s?action=%s HTTP/1.0\r\n%s\r\n", P, action, auth);
socket_free(&s);
}
error:
FREE(auth);
}
int main()
{
lib_init();
socket_t * server = socket_new();
int port = 5001;
if(-1 == socket_bind(server, port)) {
printf("port %i is busy\n", port);
exit(1);
}
socket_listen(server);
char buf[10000];
socket_t * client = NULL;
while(1)
{
client = socket_accept(server);
socket_read(client, buf, sizeof(buf));
printf("%s",buf);
if (strlen(buf) != 0){
http_request_t rs;
rs = http_request_parse(buf);
if (strcmp(rs.method,"GET") == 0 && strcmp(rs.uri, "/info") == 0 )
{
server_info(client);
}
}
}
return 0;
}
int test_tcp() {
int fd = socket_new(SOCK_STREAM);
fd =socket_bind(fd, "", 9000);
fd = socket_listen(fd);
printf("socket fd: %d\n", fd);
char cip[16] = {0};
int connfd = socket_accept(fd, cip);
if (connfd < 0) {
printf("accept failed\n");
return -1;
}
printf("start to recv\n");
char* msg = (char*)socket_recv(connfd);
printf("body=%s\n", msg);
socket_send(connfd, "back from server", strlen("back from server"));
free(msg);
close(connfd);
close(fd);
return 0;
}
bool hci_inject_open(const hci_t *hci_interface) {
assert(listen_socket == NULL);
assert(thread == NULL);
assert(clients == NULL);
assert(hci_interface != NULL);
hci = hci_interface;
thread = thread_new("hci_inject");
if (!thread)
goto error;
clients = list_new(client_free);
if (!clients)
goto error;
listen_socket = socket_new();
if (!listen_socket)
goto error;
if (!socket_listen(listen_socket, LISTEN_PORT))
goto error;
socket_register(listen_socket, thread_get_reactor(thread), NULL, accept_ready, NULL);
return true;
error:;
interface.close();
return false;
}
STATIC mp_obj_t socket_make_new(const mp_obj_type_t *type, size_t n_args, size_t n_kw, const mp_obj_t *args) {
mp_arg_check_num(n_args, n_kw, 0, 4, false);
socket_obj_t *socket = socket_new();
int family = AF_INET;
int socktype = SOCK_STREAM;
int proto = -1;
if (n_args >= 1) {
family = mp_obj_get_int(args[0]);
if (n_args >= 2) {
socktype = mp_obj_get_int(args[1]);
if (n_args >= 3) {
proto = mp_obj_get_int(args[2]);
}
}
}
if (proto == -1) {
proto = IPPROTO_TCP;
if (socktype != SOCK_STREAM) {
proto = IPPROTO_UDP;
}
}
socket->ctx = zsock_socket(family, socktype, proto);
RAISE_SOCK_ERRNO(socket->ctx);
return MP_OBJ_FROM_PTR(socket);
}
static void open_server(SendMail_T *S) {
MailServer_T mta = Run.mailservers;
if (mta) {
S->server = mta->host;
S->port = mta->port;
S->username = mta->username;
S->password = mta->password;
S->ssl = mta->ssl;
} else {
THROW(IOException, "No mail servers are defined -- see manual for 'set mailserver' statement");
}
do {
/* wait with ssl-connect if SSL_VERSION_TLSV1 is set (rfc2487) */
if (! S->ssl.use_ssl || S->ssl.version == SSL_VERSION_TLSV1)
S->socket = socket_new(S->server, S->port, SOCKET_TCP, FALSE, Run.mailserver_timeout);
else
S->socket = socket_create_t(S->server, S->port, SOCKET_TCP, S->ssl, Run.mailserver_timeout);
if (S->socket)
break;
LogError("Cannot open a connection to the mailserver '%s:%i' -- %s\n", S->server, S->port, STRERROR);
if (mta && (mta = mta->next)) {
S->server = mta->host;
S->port = mta->port;
S->username = mta->username;
S->password = mta->password;
S->ssl = mta->ssl;
LogInfo("Trying the next mail server '%s:%i'\n", S->server, S->port);
continue;
} else {
THROW(IOException, "No mail servers are available");
}
} while (TRUE);
S->quit = TRUE;
}
STATIC mp_obj_t socket_make_new(const mp_obj_type_t *type_in, size_t n_args, size_t n_kw, const mp_obj_t *args) {
(void)type_in;
(void)n_kw;
int family = AF_INET;
int type = SOCK_STREAM;
int proto = 0;
if (n_args > 0) {
assert(MP_OBJ_IS_SMALL_INT(args[0]));
family = MP_OBJ_SMALL_INT_VALUE(args[0]);
if (n_args > 1) {
assert(MP_OBJ_IS_SMALL_INT(args[1]));
type = MP_OBJ_SMALL_INT_VALUE(args[1]);
if (n_args > 2) {
assert(MP_OBJ_IS_SMALL_INT(args[2]));
proto = MP_OBJ_SMALL_INT_VALUE(args[2]);
}
}
}
int fd = socket(family, type, proto);
RAISE_ERRNO(fd, errno);
return MP_OBJ_FROM_PTR(socket_new(fd));
}
/* See if the socket under test is a connecting socket that would emit
* this outgoing script SYN. If so, return a pointer to the socket;
* otherwise, return NULL.
*/
static struct socket *handle_connect_for_script_packet(
struct state *state, const struct packet *packet,
enum direction_t direction)
{
/* Does this packet match this socket? For now we only support
* testing one socket at a time, so we merely check whether
* the socket is connecting. (If we were to support testing
* more than one socket at a time then we'd want to check to
* see if the address tuples in the packet and socket match.)
*/
struct config *config = state->config;
struct socket *socket = state->socket_under_test; /* shortcut */
bool match = ((direction == DIRECTION_OUTBOUND) &&
packet->tcp->syn && !packet->tcp->ack);
if (!match)
return NULL;
if (config->is_wire_server) {
/* On wire servers we don't see the system calls, so
* we won't have any socket_under_test yet.
*/
match = (socket == NULL);
} else {
/* In local mode we will certainly know about this socket. */
match = ((socket != NULL) &&
(socket->state == SOCKET_ACTIVE_CONNECTING));
}
if (!match)
return NULL;
if (socket == NULL) {
/* Wire server. Create a socket for this outbound SYN
* packet. Any further packets in the test script are
* mapped here.
*/
socket = socket_new(state);
state->socket_under_test = socket;
assert(socket->state == SOCKET_INIT);
socket->address_family = packet_address_family(packet);
socket->protocol = packet_ip_protocol(packet);
socket->script.fd = -1;
socket->live.remote.ip = config->live_remote_ip;
socket->live.remote.port = htons(config->live_connect_port);
socket->live.fd = -1;
}
/* Fill in the new info about this connection. */
struct tuple tuple;
get_packet_tuple(packet, &tuple);
socket->state = SOCKET_ACTIVE_SYN_SENT;
socket->script.remote = tuple.dst;
socket->script.local = tuple.src;
socket->script.local_isn = ntohl(packet->tcp->seq);
return socket;
}
struct socket*
socketlist_register(struct socketlist* head,int fd,struct addrinfo* ai) {
struct socket* s = socket_new(fd,ai);
if (s == 0)
return 0;
socketlist_put(head,s);
return s;
}
int main(void) {
// initializing first three investors for program to start with
// initializing_END
int PORT = 5000;
lib_init();
winSock = socket_new();
db_t * db = db_new("teacher.db");
// Checking if socket is not busy, closing app if it is
if (socket_bind(winSock, PORT) == SOCKET_ERROR) {
printf("Cannot bind %i port\n", PORT);
socket_close(winSock);
socket_free(winSock);
return 0;
}
socket_listen(winSock);
char buf[10000];
socket_t * client = NULL;
// main cycle of the program
while (1) {
printf("Awaiting for connections...\n");
client = socket_accept(winSock);
// Checking if client is not null, closing app if he is
if (client == NULL) {
printf("NULL client, closing app...\n");
break;
}
int readStatus = socket_read(client, buf, sizeof(buf));
// Skipping empty request (may appear from time to time)
if (readStatus <= 0) {
printf("Empty request, skipping...\n");
socket_close(client);
socket_free(client);
continue;
}
// Printing info about the received request to console
printf(">> Got request (readStatus: %i):\n'%s'\n", readStatus, buf);
http_request_t request = http_request_parse(buf);
// check the type/path of request (API/HTML) & analyze the method (GET/POST/DELETE)
// and provide the client with proper answer
server_analyzeRequest(&request, client, db);
socket_free(client);
}
// end of program
socket_close(winSock);
socket_free(winSock);
db_free(db);
lib_free();
return 0;
}
t_server *server_new(void)
{
t_server *server = (t_server *)malloc(sizeof(t_server));
server->socket=socket_new();
server->socket->print=server_print;
return server;
}
Web_t Web_new(int port){
Web_t self = (Web_t) malloc(sizeof(Web_s));
self->dataHandler = DataHandler_new("data/investors.db");
self->serverSock = socket_new();
socket_bind(self->serverSock, port);
socket_listen(self->serverSock);
return self;
}
int main(void) {
WSADATA Data;
SOCKADDR_IN recvSockAddr;
SOCKET recvSocket;
int status;
int numrcv = 0;
struct hostent * remoteHost;
char * ip;
const char * host_name = "pb-homework.appspot.com";
char * buffer = malloc(sizeof(char) * MAXBUFLEN);;
memset(buffer,0,MAXBUFLEN);
// Initialize Windows Socket DLL
status = WSAStartup(MAKEWORD(2, 2), &Data);
if(status != 0)
{
printf("ERROR: WSAStartup unsuccessful\r\n");
return 0;
}
// Get IP address from host name
remoteHost = gethostbyname(host_name);
ip = inet_ntoa(*(struct in_addr *)*remoteHost->h_addr_list);
printf("IP address is: %s.\n", ip);
memset(&recvSockAddr, 0, sizeof(recvSockAddr)); // zero the sockaddr_in structure
recvSockAddr.sin_port=htons(PORT); // specify the port portion of the address
recvSockAddr.sin_family=AF_INET; // specify the address family as Internet
recvSockAddr.sin_addr.s_addr= inet_addr(ip); // specify ip address
// Create socket
recvSocket = socket_new();
// Connect
connect_to_server(recvSocket, recvSockAddr);
// Send request
send_initial_request(recvSocket, host_name);
receive_response(recvSocket, buffer);
// Receieve
printf("%s\r\n", buffer);
send_secret_request(recvSocket, host_name, buffer);
// Get and make
free(buffer);
buffer = malloc(sizeof(char) * MAXBUFLEN);
receive_response(recvSocket, buffer);
printf("%s\r\n", buffer);
inverse_str(buffer);
// Send
send_post(recvSocket, host_name, buffer);
// Get answer
free(buffer);
buffer = malloc(sizeof(char) * MAXBUFLEN);
receive_response(recvSocket, buffer);
printf("\nServer response:\n\n%s\n", buffer);
closesocket(recvSocket);
getchar();
// Print out receieved socket data
system("pause");
return 0;
}
server_t server_new(int port){
server_t self = (server_t) malloc(sizeof(struct server_s));
self->dataHandler = DataHandler_new("db.db");
self->serverSock = socket_new();
socket_bind(self->serverSock, port);
socket_listen(self->serverSock);
return self;
}
bool
socket_server_new (socket_t *socket, char *ip, int port, int limit)
{
if (socket_new (socket, ip, port))
{
return socket_serve (socket, limit);
}
return false;
}
STATIC mp_obj_t socket_accept(mp_obj_t self_in) {
mp_obj_socket_t *self = self_in;
struct sockaddr addr;
socklen_t addr_len = sizeof(addr);
int fd = accept(self->fd, &addr, &addr_len);
RAISE_ERRNO(fd, errno);
mp_obj_tuple_t *t = mp_obj_new_tuple(2, NULL);
t->items[0] = socket_new(fd);
t->items[1] = mp_obj_new_bytearray(addr_len, &addr);
return t;
}
char * Client_requestHTTP(const char * method, const char * path, const char * msg, const char * ipaddress, int portNumber, char * mem_p){
socket_t * clientSock = socket_new();
socket_connect(clientSock, ipaddress, portNumber);
char pathBuff[256];
sprintf(pathBuff, "%s:%d%s", ipaddress, portNumber, path);
char req[256];
sprintf(req, httpRequestStrFormat, method, pathBuff, strlen(msg), msg);
socket_write_string(clientSock, req);
socket_read(clientSock, mem_p, 100000);
return * mem_p;
}
Socket*
socket_mc_out_new(
char* name, //! Name used for debugging
char* mcast_addr, //! IP address of the multicast socket/channel.
int mcast_port, //! Port used
char* iface //! Name of the interface (eth0/eth1) to bind to
) {
SocketInt* self;
// if ((self = (SocketInt*)socket_new(name, mcast_addr, 0)) == NULL)
// return NULL;
if ((self = (SocketInt*)socket_new(name, FALSE)) == NULL)
return NULL;
// Multicast parameters
unsigned char ttl = 3;
unsigned char one = 3; // loopback
struct in_addr addr;
addr.s_addr = iface2addr(name, iface);
o_log(O_LOG_DEBUG, "socket:%s: Binding to %x\n", name, addr.s_addr);
if (setsockopt(self->sockfd, IPPROTO_IP, IP_MULTICAST_IF, &addr, sizeof(addr)) < 0) {
o_log (O_LOG_ERROR, "socket:%s: Setting outgoing interface for socket\n\t%s",
name, strerror(errno));
socket_free((Socket*)socket);
return NULL;
}
if (setsockopt(self->sockfd, IPPROTO_IP, IP_MULTICAST_TTL, &ttl,
sizeof(unsigned char)) < 0) {
o_log(O_LOG_ERROR, "socket:%s: While setting TTL parameter for multicast socket\n\t%s",
name, strerror(errno));
socket_free((Socket*)socket);
return NULL;
}
if (setsockopt(self->sockfd, IPPROTO_IP, IP_MULTICAST_LOOP,
&one, sizeof(unsigned char)) < 0) {
o_log(O_LOG_ERROR, "socket%s: While setting the loopback on multicast socket\n\t%s",
name, strerror(errno));
socket_free((Socket*)socket);
return NULL;
}
// self->addr = mcast_addr;
self->servAddr.sin_port = htons(mcast_port);
self->servAddr.sin_addr.s_addr = inet_addr(mcast_addr);
o_log(O_LOG_DEBUG, "socket:%s: Ready to send data on: %s:%d\n",
name, mcast_addr, mcast_port);
return (Socket*)self;
}
STATIC mp_obj_t socket_accept(mp_obj_t self_in) {
mp_obj_socket_t *self = MP_OBJ_TO_PTR(self_in);
// sockaddr_storage isn't stack-friendly (129 bytes or so)
//struct sockaddr_storage addr;
byte addr[32];
socklen_t addr_len = sizeof(addr);
int fd = accept(self->fd, (struct sockaddr*)&addr, &addr_len);
RAISE_ERRNO(fd, errno);
mp_obj_tuple_t *t = MP_OBJ_TO_PTR(mp_obj_new_tuple(2, NULL));
t->items[0] = MP_OBJ_FROM_PTR(socket_new(fd));
t->items[1] = mp_obj_new_bytearray(addr_len, &addr);
return MP_OBJ_FROM_PTR(t);
}
static int socket_req_listen(struct _listen_req *req, struct socket_message *msg) {
struct socket *sock = socket_new(req->fd, req->id, PROTOCOL_TCP, req->ud, 0);
if (sock == 0) {
goto _failed;
}
sock->type = SOCKET_TYPE_PLISTEN;
return -1;
_failed:
close(req->fd);
msg->ud = req->ud;
msg->id = req->id;
msg->data = "socket limit";
S.slot[HASH_ID(req->id)].type = SOCKET_TYPE_INVALID;
return SOCKET_ERR;
}
static int socket_req_bind(struct _bind_req *req, struct socket_message *msg) {
struct socket *sock;
msg->id = req->id;
msg->ud = req->ud;
msg->size = 0;
sock = socket_new(req->fd, req->id, PROTOCOL_TCP, req->ud, 1);
if (sock == 0) {
msg->data = "socket limit";
return SOCKET_ERR;
}
socket_nonblocking(req->fd);
sock->type = SOCKET_TYPE_BIND;
msg->data = "binding";
return SOCKET_OPEN;
}
int main(){
lib_init();
socket_t * serverSocket = socket_new();
socket_bind(serverSocket, 5000);
socket_listen(serverSocket);
film_maker_t* film_makers[FILM_MAKERS_AMOUNT];
for (int i = 0; i < FILM_MAKERS_AMOUNT; i++) {
film_makers[i] = film_maker_new();
}
parse(film_makers,"XML_format.xml");
while(1) {
socket_t * clientSocket = socket_accept(serverSocket);
char buf[102400];
if(socket_read(clientSocket, buf, 102400) == 0) {
socket_close(clientSocket);
socket_free(clientSocket);
puts("Skipping empty request");
continue;
}
http_request_t req = http_request_parse(buf);
server_reply(clientSocket, req, film_makers);
//puts("fghj");
socket_close(clientSocket);
socket_free(clientSocket);
}
for (int i = 0; i < 3; i++)
film_maker_free(film_makers[i]);
socket_close(serverSocket);
socket_free(serverSocket);
lib_free();
return 0;
}
void
add_child (gboolean active,
gboolean qt)
{
Socket *socket = socket_new ();
gtk_box_pack_start (GTK_BOX (vbox), socket->box, TRUE, TRUE, 0);
gtk_widget_show (socket->box);
sockets = g_slist_prepend (sockets, socket);
socket_start_child (socket, active, qt);
g_signal_connect (socket->socket, "destroy",
G_CALLBACK (socket_destroyed), socket);
}
STATIC mp_obj_t socket_accept(mp_obj_t self_in) {
socket_obj_t *socket = self_in;
socket_check_closed(socket);
struct sockaddr sockaddr;
socklen_t addrlen = sizeof(sockaddr);
int ctx = zsock_accept(socket->ctx, &sockaddr, &addrlen);
socket_obj_t *socket2 = socket_new();
socket2->ctx = ctx;
mp_obj_tuple_t *client = mp_obj_new_tuple(2, NULL);
client->items[0] = MP_OBJ_FROM_PTR(socket2);
// TODO
client->items[1] = mp_const_none;
return MP_OBJ_FROM_PTR(client);
}
int main() {
lib_init();
list_t* list=list_new();
lanser * freeLanser[10];
for (int i = 0; i < 10; i++)
freeLanser[i] = Freelanser_new();
// parse(freeLanser);
socket_t * serverSocket = socket_new();
socket_bind(serverSocket, 5000);
socket_listen(serverSocket);
while (1) {
socket_t * clientSocket = socket_accept(serverSocket);
char buf[10000]="";
if (!socket_read(clientSocket, buf, sizeof(buf))) {
puts("Skipping empty request");
socket_close(clientSocket);
socket_free(clientSocket);
continue;
}
http_request_t req = http_request_parse(buf);
server_answer(list,req,clientSocket,freeLanser);
socket_close(clientSocket);
socket_free(clientSocket);
}
socket_close(serverSocket);
socket_free(serverSocket);
lib_free();
list_free(list);
return 0;
}
static int socket_req_udp(struct _udp_req *req, struct socket_message *msg) {
int id = req->id;
int protocol;
struct socket *sock;
if (req->family == AF_INET6) {
protocol = PROTOCOL_UDPv6;
} else {
protocol = PROTOCOL_UDP;
}
sock = socket_new(req->fd, id, protocol, req->ud, 1);
if (!sock) {
close(req->fd);
S.slot[HASH_ID(id)].type = SOCKET_TYPE_INVALID;
return -1;
}
sock->type = SOCKET_TYPE_OPENED;
memset(sock->p.udp_address, 0, sizeof(sock->p.udp_address));
return -1;
}
