Boolean writeSocket(UsageEnvironment& env,
int socket, struct in_addr address, Port port,
u_int8_t ttlArg,
unsigned char* buffer, unsigned bufferSize) {
do {
if (ttlArg != 0) {
// Before sending, set the socket's TTL:
#if defined(__WIN32__) || defined(_WIN32)
#define TTL_TYPE int
#else
#define TTL_TYPE u_int8_t
#endif
TTL_TYPE ttl = (TTL_TYPE)ttlArg;
if (setsockopt(socket, IPPROTO_IP, IP_MULTICAST_TTL,
(const char*)&ttl, sizeof ttl) < 0) {
socketErr(env, "setsockopt(IP_MULTICAST_TTL) error: ");
break;
}
}
MAKE_SOCKADDR_IN(dest, address.s_addr, port.num());
int bytesSent = sendto(socket, (char*)buffer, bufferSize, 0,
(struct sockaddr*)&dest, sizeof dest);
if (bytesSent != (int)bufferSize) {
char tmpBuf[100];
sprintf(tmpBuf, "writeSocket(%d), sendTo() error: wrote %d bytes instead of %u: ", socket, bytesSent, bufferSize);
socketErr(env, tmpBuf);
break;
}
return True;
} while (0);
return False;
}
//for send INADDR_BROADCAST
int create_broadcast_socket(unsigned int port)
{
MAKE_SOCKADDR_IN(adr_srvr,INADDR_ANY,htons(port));
//struct sockaddr_in adr_srvr;
int len_srvr = sizeof(adr_srvr);
int fd = socket(AF_INET, SOCK_DGRAM, 0);
if(fd==-1){
printf("create_broadcast_socket socket error, %d, %s\n", errno, strerror(errno));
return -1;
}
if(enable_broadcast(fd)==-1){
close(fd);
return -1;
}
if(bind(fd, (struct sockaddr *)&adr_srvr, len_srvr)){
printf("create_broadcast_socket bind error, %d, %s\n", errno, strerror(errno));
close(fd);
return -1;
}
return fd;
}
MP3HTTPSource* MP3HTTPSource::createNew(UsageEnvironment& env,
NetAddress const& remoteAddress,
Port remotePort,
char const* remoteHostName,
char const* fileName) {
int ourSocket = -1;
MP3HTTPSource* newSource = NULL;
do {
// Create a stream socket for this source.
// Note: We don't make the socket non-blocking, because we want
// to read from it synchronously (as we do with real file sources)
ourSocket = setupStreamSocket(env, 0, False);
if (ourSocket < 0) break;
// Connect to the remote endpoint:
MAKE_SOCKADDR_IN(remoteName, *(unsigned*)(remoteAddress.data()), remotePort.num());
if (connect(ourSocket, (struct sockaddr*)&remoteName, sizeof remoteName)
!= 0) {
env.setResultErrMsg("connect() failed: ");
break;
}
// Make sure we have a big receive buffer:
if (!increaseReceiveBufferTo(env, ourSocket, 100*1024)) break;
// Try to make the new socket into a FILE*:
unsigned streamLength = 0; //#####
FILE* fid = NULL;
#if !defined(IMN_PIM) && !defined(CRIS) && !defined(_WIN32_WCE)
fid = fdopen(ourSocket, "r+b");
#endif
if (fid == NULL) {
// HACK HACK HACK #####
// We couldn't convert the socket to a FILE*; perhaps this is Windoze?
// Instead, tell the low-level to read it directly as a socket:
long ourSocket_long = (long)ourSocket;
fid = (FILE*)ourSocket_long;
streamLength = (unsigned)(-1);
}
newSource = new MP3HTTPSource(env, fid);
if (newSource == NULL) break;
newSource->assignStream(fid, streamLength);
// Write the HTTP 'GET' command:
newSource->writeGetCmd(remoteHostName, ntohs(remotePort.num()),
fileName);
// Now read the first frame header, to finish initializing the stream:
if (!newSource->initializeStream()) break;
return newSource;
} while (0);
if (ourSocket != -1) ::closeSocket(ourSocket);
Medium::close(newSource);
return NULL;
}
Boolean getSourcePort(UsageEnvironment& env, int socket, Port& port) {
portNumBits portNum = 0;
if (!getSourcePort0(socket, portNum) || portNum == 0) {
// Hack - call bind(), then try again:
MAKE_SOCKADDR_IN(name, INADDR_ANY, 0);
bind(socket, (struct sockaddr*)&name, sizeof name);
if (!getSourcePort0(socket, portNum) || portNum == 0) {
socketErr(env, "getsockname() error: ");
return False;
}
}
port = Port(portNum);
return True;
}
Boolean writeSocket(UsageEnvironment& env,
int socket, struct in_addr address, portNumBits portNum,
unsigned char* buffer, unsigned bufferSize) {
do {
MAKE_SOCKADDR_IN(dest, address.s_addr, portNum);
int bytesSent = sendto(socket, (char*)buffer, bufferSize, 0,
(struct sockaddr*)&dest, sizeof dest);
if (bytesSent != (int)bufferSize) {
char tmpBuf[100];
sprintf(tmpBuf, "writeSocket(%d), sendTo() error: wrote %d bytes instead of %u: ", socket, bytesSent, bufferSize);
socketErr(env, tmpBuf);
break;
}
return True;
} while (0);
return False;
}
int create_multicast_socket(char *multi_addr, unsigned int port, char* interface_ip)
{
//struct sockaddr_in adr_srvr;
MAKE_SOCKADDR_IN(adr_srvr,INADDR_ANY,htons(port));
//struct sockaddr_in mcast_addr;
int len_srvr = sizeof(adr_srvr);
int fd = socket(AF_INET, SOCK_DGRAM, 0);
if(fd==-1){
printf("create_broadcast_socket socket error, %d, %s\n", errno, strerror(errno));
return -1;
}
if(bind(fd, (struct sockaddr *)&adr_srvr, len_srvr)){
printf("create_udp_socket socket bind, %d, %s\n", errno, strerror(errno));
close(fd);
return -1;
}
int loop = 0;
setsockopt(fd,IPPROTO_IP,IP_MULTICAST_LOOP,&loop,sizeof(loop));
// Set the sending interface for multicasts, if it's not the default:
/*memset(&mcast_addr,0,sizeof(mcast_addr));
mcast_addr.sin_family = AF_INET;
mcast_addr.sin_addr.s_addr = inet_addr(multi_addr);
mcast_addr.sin_port = htons(port);
if (adr_srvr.sin_addr.s_addr != INADDR_ANY) {
struct in_addr addr;
addr.s_addr = adr_srvr.sin_addr.s_addr;
if (setsockopt(fd, IPPROTO_IP, IP_MULTICAST_IF, (const char*)&addr, sizeof(addr)) < 0) {
printf("create_multicast_socket IP_MULTICAST_IF, %d, %s\n", errno, strerror(errno));
close(fd);
return -1;
}
}*/
return fd;
}
void RTSPRegisterSender::grabConnection(int& sock, struct sockaddr_in& remoteAddress) {
sock = grabSocket();
MAKE_SOCKADDR_IN(remoteAddr, fServerAddress, htons(fRemoteClientPortNum));
remoteAddress = remoteAddr;
}
int setupDatagramSocket(UsageEnvironment& env, Port port) {
if (!initializeWinsockIfNecessary()) {
socketErr(env, "Failed to initialize 'winsock': ");
return -1;
}
int newSocket = socket(AF_INET, SOCK_DGRAM, 0);
// printf("setupDatagramSocket: newSocket %d\n", newSocket); //jay
if (newSocket < 0) {
socketErr(env, "unable to create datagram socket: ");
return newSocket;
}
if (setsockopt(newSocket, SOL_SOCKET, SO_REUSEADDR,
(const char*)&reuseFlag, sizeof reuseFlag) < 0) {
socketErr(env, "setsockopt(SO_REUSEADDR) error: ");
closeSocket(newSocket);
return -1;
}
#if defined(__WIN32__) || defined(_WIN32)
// Windoze doesn't properly handle SO_REUSEPORT or IP_MULTICAST_LOOP
#else
#ifdef SO_REUSEPORT
if (setsockopt(newSocket, SOL_SOCKET, SO_REUSEPORT,
(const char*)&reuseFlag, sizeof reuseFlag) < 0) {
socketErr(env, "setsockopt(SO_REUSEPORT) error: ");
closeSocket(newSocket);
return -1;
}
#endif
#ifdef IP_MULTICAST_LOOP
const u_int8_t loop = 1;
if (setsockopt(newSocket, IPPROTO_IP, IP_MULTICAST_LOOP,
(const char*)&loop, sizeof loop) < 0) {
socketErr(env, "setsockopt(IP_MULTICAST_LOOP) error: ");
closeSocket(newSocket);
return -1;
}
#endif
#endif
// Note: Windoze requires binding, even if the port number is 0
netAddressBits addr = INADDR_ANY;
#if defined(__WIN32__) || defined(_WIN32)
#else
if (port.num() != 0 || ReceivingInterfaceAddr != INADDR_ANY) {
#endif
if (port.num() == 0) addr = ReceivingInterfaceAddr;
MAKE_SOCKADDR_IN(name, addr, port.num());
if (bind(newSocket, (struct sockaddr*)&name, sizeof name) != 0) {
char tmpBuffer[100];
sprintf(tmpBuffer, "bind() error (port number: %d): ",
ntohs(port.num()));
socketErr(env, tmpBuffer);
closeSocket(newSocket);
return -1;
}
// printf("setupDatagramSocket: bind %s:%d\n", inet_ntoa(name.sin_addr), ntohs(name.sin_port)); //jay
#if defined(__WIN32__) || defined(_WIN32)
#else
}
#endif
// Set the sending interface for multicasts, if it's not the default:
if (SendingInterfaceAddr != INADDR_ANY) {
struct in_addr addr;
addr.s_addr = SendingInterfaceAddr;
if (setsockopt(newSocket, IPPROTO_IP, IP_MULTICAST_IF,
(const char*)&addr, sizeof addr) < 0) {
socketErr(env, "error setting outgoing multicast interface: ");
closeSocket(newSocket);
return -1;
}
}
return newSocket;
}
int setupStreamSocket(UsageEnvironment& env,
Port port, Boolean makeNonBlocking) {
if (!initializeWinsockIfNecessary()) {
socketErr(env, "Failed to initialize 'winsock': ");
return -1;
}
int newSocket = socket(AF_INET, SOCK_STREAM, 0);
if (newSocket < 0) {
socketErr(env, "unable to create stream socket: ");
return newSocket;
}
if (setsockopt(newSocket, SOL_SOCKET, SO_REUSEADDR,
(const char*)&reuseFlag, sizeof reuseFlag) < 0) {
socketErr(env, "setsockopt(SO_REUSEADDR) error: ");
closeSocket(newSocket);
return -1;
}
// SO_REUSEPORT doesn't really make sense for TCP sockets, so we
// normally don't set them. However, if you really want to do this
// #define REUSE_FOR_TCP
#ifdef REUSE_FOR_TCP
#if defined(__WIN32__) || defined(_WIN32)
// Windoze doesn't properly handle SO_REUSEPORT
#else
#ifdef SO_REUSEPORT
if (setsockopt(newSocket, SOL_SOCKET, SO_REUSEPORT,
(const char*)&reuseFlag, sizeof reuseFlag) < 0) {
socketErr(env, "setsockopt(SO_REUSEPORT) error: ");
closeSocket(newSocket);
return -1;
}
#endif
#endif
#endif
// Note: Windoze requires binding, even if the port number is 0
#if defined(__WIN32__) || defined(_WIN32)
#else
if (port.num() != 0 || ReceivingInterfaceAddr != INADDR_ANY) {
#endif
MAKE_SOCKADDR_IN(name, ReceivingInterfaceAddr, port.num());
if (bind(newSocket, (struct sockaddr*)&name, sizeof name) != 0) {
char tmpBuffer[100];
sprintf(tmpBuffer, "bind() error (port number: %d): ",
ntohs(port.num()));
socketErr(env, tmpBuffer);
closeSocket(newSocket);
return -1;
}
#if defined(__WIN32__) || defined(_WIN32)
#else
}
#endif
if (makeNonBlocking) {
if (!makeSocketNonBlocking(newSocket)) {
socketErr(env, "failed to make non-blocking: ");
closeSocket(newSocket);
return -1;
}
}
return newSocket;
}
