char* SIPClient::inviteWithPassword(char const* url, char const* username,
char const* password) {
delete[] (char*)fUserName; fUserName = strDup(username);
fUserNameSize = strlen(fUserName);
Authenticator authenticator;
authenticator.setUsernameAndPassword(username, password);
char* inviteResult = invite(url, &authenticator);
if (inviteResult != NULL) {
// We are already authorized
return inviteResult;
}
// The "realm" and "nonce" fields should have been filled in:
if (authenticator.realm() == NULL || authenticator.nonce() == NULL) {
// We haven't been given enough information to try again, so fail:
return NULL;
}
// Try again (but with the same CallId):
inviteResult = invite1(&authenticator);
if (inviteResult != NULL) {
// The authenticator worked, so use it in future requests:
fValidAuthenticator = authenticator;
}
return inviteResult;
}
int sendBeepSound(const char* rtspURL, const char* username, const char* password) {
FILE* fp = fopen(WAVE_FILE, "r");
if ( fp == NULL )
{
LOG("wave file not exists : %s", WAVE_FILE);
return -1;
}
else
{
fclose(fp);
}
// Begin by setting up our usage environment:
TaskScheduler* scheduler = BasicTaskScheduler::createNew();
UsageEnvironment* env = BasicUsageEnvironment::createNew(*scheduler);
// Begin by creating a "RTSPClient" object. Note that there is a separate "RTSPClient" object for each stream that we wish
// to receive (even if more than stream uses the same "rtsp://" URL).
ourRTSPClient* rtspClient = ourRTSPClient::createNew(*env, rtspURL, RTSP_CLIENT_VERBOSITY_LEVEL, "SCBT BackChannel");
if (rtspClient == NULL) {
*env << "Failed to create a RTSP client for URL \"" << rtspURL << "\": " << env->getResultMsg() << "\n";
env->reclaim(); env = NULL;
delete scheduler; scheduler = NULL;
return -2;
}
rtspClient->bRequireBackChannel = bEnableBackChannel;
// Next, send a RTSP "DESCRIBE" command, to get a SDP description for the stream.
// Note that this command - like all RTSP commands - is sent asynchronously; we do not block, waiting for a response.
// Instead, the following function call returns immediately, and we handle the RTSP response later, from within the event loop:
Authenticator auth;
auth.setUsernameAndPassword(username, password);
rtspClient->sendDescribeCommand(continueAfterDESCRIBE, &auth);
//continueAfterSETUP(rtspClient, 0, new char[2]);
//startPlay(rtspClient);
// All subsequent activity takes place within the event loop:
env->taskScheduler().doEventLoop(&(rtspClient->scs.eventLoopWatchVariable));
// This function call does not return, unless, at some point in time, "eventLoopWatchVariable" gets set to something non-zero.
// If you choose to continue the application past this point (i.e., if you comment out the "return 0;" statement above),
// and if you don't intend to do anything more with the "TaskScheduler" and "UsageEnvironment" objects,
// then you can also reclaim the (small) memory used by these objects by uncommenting the following code:
env->reclaim(); env = NULL;
delete scheduler; scheduler = NULL;
return 0;
}
Boolean DarwinInjector
::setDestination(char const* remoteRTSPServerNameOrAddress,
char const* remoteFileName,
char const* sessionName,
char const* sessionInfo,
portNumBits remoteRTSPServerPortNumber,
char const* remoteUserName,
char const* remotePassword,
char const* sessionAuthor,
char const* sessionCopyright,
int timeout) {
char* sdp = NULL;
char* url = NULL;
Boolean success = False; // until we learn otherwise
do {
// Construct a RTSP URL for the remote stream:
char const* const urlFmt = "rtsp://%s:%u/%s";
unsigned urlLen
= strlen(urlFmt) + strlen(remoteRTSPServerNameOrAddress) + 5 /* max short len */ + strlen(remoteFileName);
url = new char[urlLen];
sprintf(url, urlFmt, remoteRTSPServerNameOrAddress, remoteRTSPServerPortNumber, remoteFileName);
// Begin by creating our RTSP client object:
fRTSPClient = new RTSPClientForDarwinInjector(envir(), url, fVerbosityLevel, fApplicationName, this);
if (fRTSPClient == NULL) break;
// Get the remote RTSP server's IP address:
struct in_addr addr;
{
NetAddressList addresses(remoteRTSPServerNameOrAddress);
if (addresses.numAddresses() == 0) break;
NetAddress const* address = addresses.firstAddress();
addr.s_addr = *(unsigned*)(address->data());
}
AddressString remoteRTSPServerAddressStr(addr);
// Construct a SDP description for the session that we'll be streaming:
char const* const sdpFmt =
"v=0\r\n"
"o=- %u %u IN IP4 127.0.0.1\r\n"
"s=%s\r\n"
"i=%s\r\n"
"c=IN IP4 %s\r\n"
"t=0 0\r\n"
"a=x-qt-text-nam:%s\r\n"
"a=x-qt-text-inf:%s\r\n"
"a=x-qt-text-cmt:source application:%s\r\n"
"a=x-qt-text-aut:%s\r\n"
"a=x-qt-text-cpy:%s\r\n";
// plus, %s for each substream SDP
unsigned sdpLen = strlen(sdpFmt)
+ 20 /* max int len */ + 20 /* max int len */
+ strlen(sessionName)
+ strlen(sessionInfo)
+ strlen(remoteRTSPServerAddressStr.val())
+ strlen(sessionName)
+ strlen(sessionInfo)
+ strlen(fApplicationName)
+ strlen(sessionAuthor)
+ strlen(sessionCopyright)
+ fSubstreamSDPSizes;
unsigned const sdpSessionId = our_random32();
unsigned const sdpVersion = sdpSessionId;
sdp = new char[sdpLen];
sprintf(sdp, sdpFmt,
sdpSessionId, sdpVersion, // o= line
sessionName, // s= line
sessionInfo, // i= line
remoteRTSPServerAddressStr.val(), // c= line
sessionName, // a=x-qt-text-nam: line
sessionInfo, // a=x-qt-text-inf: line
fApplicationName, // a=x-qt-text-cmt: line
sessionAuthor, // a=x-qt-text-aut: line
sessionCopyright // a=x-qt-text-cpy: line
);
char* p = &sdp[strlen(sdp)];
SubstreamDescriptor* ss;
for (ss = fHeadSubstream; ss != NULL; ss = ss->next()) {
sprintf(p, "%s", ss->sdpLines());
p += strlen(p);
}
// Do a RTSP "ANNOUNCE" with this SDP description:
Authenticator auth;
Authenticator* authToUse = NULL;
if (remoteUserName[0] != '\0' || remotePassword[0] != '\0') {
auth.setUsernameAndPassword(remoteUserName, remotePassword);
authToUse = &auth;
}
fWatchVariable = 0;
(void)fRTSPClient->sendAnnounceCommand(sdp, genericResponseHandler, authToUse);
// Now block (but handling events) until we get a response:
envir().taskScheduler().doEventLoop(&fWatchVariable);
delete[] fResultString;
if (fResultCode != 0) break; // an error occurred with the RTSP "ANNOUNCE" command
// Next, tell the remote server to start receiving the stream from us.
// (To do this, we first create a "MediaSession" object from the SDP description.)
fSession = MediaSession::createNew(envir(), sdp);
if (fSession == NULL) break;
ss = fHeadSubstream;
MediaSubsessionIterator iter(*fSession);
MediaSubsession* subsession;
ss = fHeadSubstream;
unsigned streamChannelId = 0;
while ((subsession = iter.next()) != NULL) {
if (!subsession->initiate()) break;
fWatchVariable = 0;
(void)fRTSPClient->sendSetupCommand(*subsession, genericResponseHandler,
True /*streamOutgoing*/,
True /*streamUsingTCP*/);
// Now block (but handling events) until we get a response:
envir().taskScheduler().doEventLoop(&fWatchVariable);
delete[] fResultString;
if (fResultCode != 0) break; // an error occurred with the RTSP "SETUP" command
// Tell this subsession's RTPSink and RTCPInstance to use
// the RTSP TCP connection:
ss->rtpSink()->setStreamSocket(fRTSPClient->socketNum(), streamChannelId++);
if (ss->rtcpInstance() != NULL) {
ss->rtcpInstance()->setStreamSocket(fRTSPClient->socketNum(),
streamChannelId++);
}
ss = ss->next();
}
if (subsession != NULL) break; // an error occurred above
// Tell the RTSP server to start:
fWatchVariable = 0;
(void)fRTSPClient->sendPlayCommand(*fSession, genericResponseHandler);
// Now block (but handling events) until we get a response:
envir().taskScheduler().doEventLoop(&fWatchVariable);
delete[] fResultString;
if (fResultCode != 0) break; // an error occurred with the RTSP "PLAY" command
// Finally, make sure that the output TCP buffer is a reasonable size:
increaseSendBufferTo(envir(), fRTSPClient->socketNum(), 100*1024);
success = True;
} while (0);
delete[] sdp;
delete[] url;
return success;
}
