/* * SRT - Secure, Reliable, Transport * Copyright (c) 2017 Haivision Systems Inc. * * This library is free software; you can redistribute it and/or * modify it under the terms of the GNU Lesser General Public * License as published by the Free Software Foundation; either * version 2.1 of the License, or (at your option) any later version. * * This library is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU * Lesser General Public License for more details. * * You should have received a copy of the GNU Lesser General Public * License along with this library; If not, see */ #include #include #ifdef _WIN32 #define usleep(x) Sleep(x / 1000) #else #include #endif #include "srt.h" struct { const char* name; int gtype; } group_types [] = { { "broadcast", SRT_GTYPE_BROADCAST } // Others will follow }; #define SIZE(array) (sizeof array/sizeof(array[0])) // Note that in this example application there's a socket // used first to connect to the service and then it will be // used for writing. Therefore the same function will be used // for waiting for the socket to be connected and then to wait // for write-ready on the socket used for transmission. For a // model of waiting for read-ready see test-c-server-bonding.c file. int WaitForWriteReady(int eid, SRTSOCKET ss) { int ready_err[2]; int ready_err_len = 2; int ready_out[2]; int ready_out_len = 2; int st = srt_epoll_wait(eid, ready_err, &ready_err_len, ready_out, &ready_out_len, -1, 0, 0, 0, 0); // Note: with indefinite wait time we can either have a connection reported // or possibly error. Also srt_epoll_wait never returns 0 - at least the number // of ready connections is reported or -1 is returned for error, including timeout. if (st < 1) { fprintf(stderr, "srt_epoll_wait: %s\n", srt_getlasterror_str()); return 0; } // Check if this was reported as error-ready, in which case it doesn't // matter if read-ready. if (ready_err[0] == ss) { int reason = srt_getrejectreason(ss); fprintf(stderr, "srt_epoll_wait: socket @%d reported error reason=%d: %s\n", ss, reason, srt_rejectreason_str(reason)); return 0; } return 1; } int main(int argc, char** argv) { int ss, st; struct sockaddr_in sa; //int yes = 1; // for options, none needed so far const char message [] = "This message should be sent to the other side"; if (argc < 3) { fprintf(stderr, "Usage: %s { }... \n", argv[0]); return 1; } int gtype = SRT_GTYPE_BROADCAST; size_t i; for (i = 0; i < SIZE(group_types); ++i) if (0 == strcmp(group_types[i].name, argv[1])) { gtype = group_types[i].gtype; break; } int is_nonblocking = 0; size_t nmemb = argc - 2; if (nmemb < 2) { fprintf(stderr, "Usage error: no members specified\n"); return 1; } if (nmemb % 2) { // Last argument is then optionset --nmemb; const char* opt = argv[argc-1]; if (strchr(opt, 'n')) is_nonblocking = 1; } nmemb /= 2; printf("srt startup\n"); srt_startup(); // Declare all variables before any destructive goto. // In C++ such a code that jumps over initialization would be illegal, // in C it causes an uninitialized value to be used. int eid = -1; int write_modes = SRT_EPOLL_OUT | SRT_EPOLL_ERR; SRT_SOCKGROUPDATA* grpdata = NULL; SRT_SOCKGROUPCONFIG* grpconfig = calloc(nmemb, sizeof (SRT_SOCKGROUPCONFIG)); printf("srt group\n"); ss = srt_create_group(gtype); if (ss == SRT_ERROR) { fprintf(stderr, "srt_create_group: %s\n", srt_getlasterror_str()); goto end; } const int B = 2; for (i = 0; i < nmemb; ++i) { printf("srt remote address #%zi\n", i); sa.sin_family = AF_INET; sa.sin_port = htons(atoi(argv[B + 2*i + 1])); if (inet_pton(AF_INET, argv[B + 2*i], &sa.sin_addr) != 1) { fprintf(stderr, "inet_pton: can't resolve address: %s\n", argv[B + 2*i]); goto end; } grpconfig[i] = srt_prepare_endpoint(NULL, (struct sockaddr*)&sa, sizeof sa); } if (is_nonblocking) { int blockingmode = 0; srt_setsockflag(ss, SRTO_RCVSYN, &blockingmode, sizeof (blockingmode)); eid = srt_epoll_create(); srt_epoll_add_usock(eid, ss, &write_modes); } printf("srt connect (group)\n"); // Note: this function unblocks at the moment when at least one connection // from the array is established (no matter which one); the others will // continue in background. st = srt_connect_group(ss, grpconfig, nmemb); if (st == SRT_ERROR) { fprintf(stderr, "srt_connect: %s\n", srt_getlasterror_str()); goto end; } // In non-blocking mode the srt_connect function returns immediately // and displays only errors of the initial usage, not runtime errors. // These could be reported by epoll. if (is_nonblocking) { // WRITE-ready means connected printf("srt wait for socket reporting connection success\n"); if (!WaitForWriteReady(eid, ss)) goto end; } // In non-blocking mode now is the time to possibly change the epoll. // As this socket will be used for writing, it is in the right mode already. // Just set the right flag, as for non-blocking connect it needs RCVSYN. if (is_nonblocking) { int blockingmode = 0; srt_setsockflag(ss, SRTO_SNDSYN, &blockingmode, sizeof (blockingmode)); } // Important: Normally you need that at least one link is ready for // the group link to be ready. All but first are done actually in // background, so this sleep only makes it more probable. If you'd like // to make sure that ALL links are established - by some reason - then // you'd have to subscribe for epoll event SRT_EPOLL_UPDATE and after the // connect function exits do checks by srt_group_data to see if all links // are established, and if not, repeat it after srt_epoll_wait for the // SRT_EPOLL_UPDATE signal. printf("sleeping 1s to make it probable all links are established\n"); sleep(1); grpdata = calloc(nmemb, sizeof (SRT_SOCKGROUPDATA)); for (i = 0; i < 100; i++) { printf("srt sendmsg2 #%zd >> %s\n",i,message); SRT_MSGCTRL mc = srt_msgctrl_default; mc.grpdata = grpdata; mc.grpdata_size = nmemb; // Set maximum known if (is_nonblocking) { // Block in epoll as srt_recvmsg2 will not block. if (!WaitForWriteReady(eid, ss)) goto end; } st = srt_sendmsg2(ss, message, sizeof message, &mc); if (st == SRT_ERROR) { fprintf(stderr, "srt_sendmsg: %s\n", srt_getlasterror_str()); goto end; } // Perform the group check. This can be used to recognize broken connections // and probably reestablish them by calling `srt_connect` for them. Here they // are only shown. printf(" ++ Group status [%zi]:", mc.grpdata_size); if (!mc.grpdata) { printf(" (ERROR: array too small!)\n"); } else { for (i = 0; i < mc.grpdata_size; ++i) { printf( "[%zd] result=%d state=%s ", i, mc.grpdata[i].result, mc.grpdata[i].sockstate <= SRTS_CONNECTING ? "pending" : mc.grpdata[i].sockstate == SRTS_CONNECTED ? "connected" : "broken"); } printf("\n"); } usleep(1000); // 1 ms } end: if (eid != -1) { srt_epoll_release(eid); } printf("srt close\n"); st = srt_close(ss); if (st == SRT_ERROR) { fprintf(stderr, "srt_close: %s\n", srt_getlasterror_str()); return 1; } free(grpdata); free(grpconfig); //cleanup: printf("srt cleanup\n"); srt_cleanup(); return 0; }