onekopaka/Darwin-Streaming-Server
1
0
Fork 0
Code Issues Pull requests Releases Wiki Activity
Darwin-Streaming-Server/PlaylistBroadcaster.tproj/PlaylistBroadcaster.cpp

2236 lines
72 KiB
C++
Raw Normal View History

Very rough first start, not even everything added
2017-03-07 14:51:44 -08:00
/*
*
* @APPLE_LICENSE_HEADER_START@
*
* Copyright (c) 1999-2008 Apple Inc. All Rights Reserved.
*
* This file contains Original Code and/or Modifications of Original Code
* as defined in and that are subject to the Apple Public Source License
* Version 2.0 (the 'License'). You may not use this file except in
* compliance with the License. Please obtain a copy of the License at
* http://www.opensource.apple.com/apsl/ and read it before using this
* file.
*
* The Original Code and all software distributed under the License are
* distributed on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER
* EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
* INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT.
* Please see the License for the specific language governing rights and
* limitations under the License.
*
* @APPLE_LICENSE_HEADER_END@
*
*/
/*
8.11.99 rt - changed references to "PlaylistBroadcaster Setup" to Broadcast Description File
8.4.99 rt - changed references to "PlaylistBroadcaster Description" to Broadcast Setup File
- addded error messages
- prefilght config file access
- require log file creation
7.27.99 rt - removed license from about display
- updated credit names
- fixed mapping of --stop to 's' from 'l'
- added about to help
8.2.99 rt - changed reference to "channel setup" to "PlaylistBroadcaster Description"
- changed &d's in qtss_printf's to %d
*/
#include <stdio.h>
#include <stdlib.h>
#include "SafeStdLib.h"
#include <signal.h>
#ifndef __MacOSX__
#include "getopt.h"
#endif
#ifndef __Win32__
#if defined (__solaris__) || defined (__osf__) || defined (__sgi__) || defined (__hpux__)
#include "daemon.h"
#else
#ifndef __FreeBSD__
#include <sys/sysctl.h>
#endif
#endif
#endif
#ifndef kVersionString
#include "../revision.h"
#endif
#include <errno.h>
#include "QTRTPFile.h"
#include "OSHeaders.h"
#include "OS.h"
#include "OSMemory.h"
#include "SocketUtils.h"
#include "Socket.h"
#include "Task.h"
#include "TimeoutTask.h"
#include "BroadcasterSession.h"
#include "OSArrayObjectDeleter.h"
#include "PickerFromFile.h"
#include "PLBroadcastDef.h"
#include "BroadcastLog.h"
#include "StringTranslator.h"
#ifndef __Win32__
#include "BCasterTracker.h"
#endif
#ifdef __Win32__
#include "getopt.h"
#endif
// must now inlcude this from the project level using the -i switch in the compiler
#ifndef __MacOSX__
#include "../revision.h"
#endif
#ifdef __MacOSX__
#include <sys/stat.h>
#endif
#include "playlist_SDPGen.h"
#include "playlist_broadcaster.h"
#include "MyAssert.h"
/*
local functions
*/
static void usage();
static void version();
static void help();
static PlaylistPicker* MakePickerFromConfig( PLBroadcastDef* broadcastParms );
static void SignalEventHandler( int signalID );
static int EvalBroadcasterErr(int err);
static const char* GetMovieFileErrString( int err );
static void RegisterEventHandlers();
static void ShowPlaylistStatus();
static void StopABroadcast( const char* arg );
static bool DoSDPGen( PLBroadcastDef *broadcastParms, bool preflight, bool overWriteSDP, bool generateNewSDP, int* numErrorsPtr, char* refMovie);
static bool AddOurPIDToTracker( const char* bcastSetupFilePath );
static void Cleanup();
/* -- preflighting --*/
static int MyAccess( const char* path, int mode );
static int PreflightSDPFileAccess( const char * sdpPath );
static int PreflightDestinationAddress( const char *destAddress );
static int PreflightBasePort( const char *basePort );
static int PreflightReferenceMovieAccess( const char *refMoviePath );
static bool PreflightTrackerFileAccess( int mode );
static bool PreFlightSetupFile( const char * bcastSetupFilePath );
static int PreflightClientBufferDelay( const char * delay, Float32 *ioDelay);
static void ShowSetupParams(PLBroadcastDef* broadcastParms, const char *file);
static int PreflightDestSDPFileAccess( const char * sdpPath );
static void PreFlightOrBroadcast( const char *bcastSetupFilePath, bool preflight, bool daemonize, bool showMovieList, bool writeCurrentMovieFile, char *destinationIP,bool writeNewSDP, const char* errorFilePath);
/* changed by emil@popwire.com */
static bool FileCreateAndCheckAccess(char *theFileName);
static void PrintPlaylistElement(PLDoubleLinkedListNode<SimplePlayListElement> *node,void *file);
static void ShowPlaylistElements(PlaylistPicker *picker,FILE *file);
static void RemoveFiles(PLBroadcastDef* broadcastParms);
/* ***************************************************** */
/*
local variables
*/
static char* sgProgramName; // the actual program name as input at commmand line
static char* sgTrackerDirPath = "/var/run";
static char* sgTrackerFilePath = "/var/run/broadcastlist";
static BroadcastLog* sgLogger = NULL;
static bool sgTrackingSucceeded = false;
static BroadcasterSession* sBroadcasterSession = NULL;
static StrPtrLen sSetupDirPath;
static PlaylistPicker* sTempPicker = NULL;
static SInt32 sElementCount = 0;
static SInt32 sMaxUpcomingListSize = 5;
static PLBroadcastDef* sBroadcastParms = NULL;
enum {maxSDPbuffSize = 10000};
static char sSDPBuffer[maxSDPbuffSize] = {0};
static bool sQuitImmediate = false;
static bool sAnnounceBroadcast = false;
static bool sPushOverTCP = false;
static int sRTSPClientError = 0;
static bool sErrorEvaluted = false;
static bool sDeepDebug = false;
static int sNumWarnings = 0;
static int sNumErrors = 0;
static bool sPreflight = false;
static bool sCleanupDone = false;
static bool sBurst = false;
//+ main is getting too big.. need to clean up and separate the command actions
// into a separate file.
int main(int argc, char *argv[]) {
char *bcastSetupFilePath = NULL;
bool daemonize = true;
int anOption = 0;
bool preflight = false;
bool showMovieList = false;
bool writeCurrentMovieFile = false;
int displayedOptions = 0; // count number of command line options we displayed
bool needsTracker = false; // set to true when PLB needs tracker access
bool needsLogfile = false; // set to true when PLB needs tracker access
char* destinationIP = NULL;
bool writeNewSDP = false;
char* errorlog = NULL;
extern char* optarg;
extern int optind;
#ifdef __Win32__
//
// Start Win32 DLLs
WORD wsVersion = MAKEWORD(1, 1);
WSADATA wsData;
(void)::WSAStartup(wsVersion, &wsData);
#endif
QTRTPFile::Initialize(); // do only once
OS::Initialize();
OSThread::Initialize();
OSMemory::SetMemoryError(ENOMEM);
Socket::Initialize();
SocketUtils::Initialize(false);
if (SocketUtils::GetNumIPAddrs() == 0)
{
qtss_printf("Network initialization failed. IP must be enabled to run PlaylistBroadcaster\n");
::exit(0);
}
#ifdef __MacOSX__
(void) ::umask(S_IWOTH); // make sure files are opened with default of owner -rw-rw-r-
#endif
sgProgramName = argv[0];
#ifdef __Win32__
while ((anOption = getopt(argc, argv, "vhdcpbDtai:fe:" )) != EOF)
#else
while ((anOption = getopt(argc, argv, "vhdcpbDls:tai:fe:" )) != EOF)
#endif
{
switch(anOption)
{
case 'b':
sBurst = true;
break;
case 'v':
::version();
::usage();
return 0;
case 'h':
::help();
displayedOptions++;
break;
case 'd':
daemonize = false;
break;
case 'c':
writeCurrentMovieFile = true;
break;
/*
case 'm':
showMovieList = true;
daemonize = false;
break;
*/
case 'p':
preflight = true;
daemonize = false;
needsTracker = true;
needsLogfile = true;
break;
case 'D':
sDeepDebug = true;
daemonize = false;
break;
#ifndef __Win32__
case 'l':
// show playlist broadcast status
if (!PreflightTrackerFileAccess( R_OK )) // check for read access.
::exit(-1);
ShowPlaylistStatus(); // <- exits() on failure
displayedOptions++;
break;
case 's':
// stop a playlist broadcast
// is there one to kill?
if (!PreflightTrackerFileAccess( R_OK | W_OK )) // check for read access.
::exit(-1);
StopABroadcast( optarg ); // <- exits() on failure
displayedOptions++;
break;
#endif
case 't':
sAnnounceBroadcast = true;
sPushOverTCP = true;
break;
case 'a':
sAnnounceBroadcast = true;
break;
case 'i':
destinationIP = (char*)malloc(strlen(optarg)+1);
strcpy(destinationIP, optarg);
qtss_printf("destinationIP =%s\n",destinationIP);
break;
case 'f':
writeNewSDP = true;
break;
case 'e':
errorlog = (char*)malloc(strlen(optarg)+1);
strcpy(errorlog, optarg);
break;
default:
::usage();
::exit(-1);
}
}
if (argv[optind] != NULL)
{
bcastSetupFilePath = (char*)malloc(strlen(argv[optind])+1);
strcpy(bcastSetupFilePath, argv[optind]);
}
sPreflight = preflight;
if (errorlog != NULL)
{
if (preflight)
freopen(errorlog, "w", stdout);
else
freopen(errorlog, "a", stdout);
::setvbuf(stdout, (char *)NULL, _IONBF, 0);
}
// preflight needs a description file
if ( preflight && !bcastSetupFilePath )
{ qtss_printf("- PlaylistBroadcaster: Error. \"Preflight\" requires a broadcast description file.\n" );
::usage();
::exit(-1);
}
// don't complain about lack of description File if we were asked to display some options.
if ( displayedOptions > 0 && !bcastSetupFilePath )
::exit(0); // <-- we displayed option info, but have no description file to broadcast
PreFlightOrBroadcast( bcastSetupFilePath, preflight, daemonize, showMovieList, writeCurrentMovieFile,destinationIP,writeNewSDP, errorlog ); // <- exits() on failure -- NOT ANYMORE
return 0;
}
BroadcasterSession *StartBroadcastRTSPSession(PLBroadcastDef *broadcastParms)
{
TaskThreadPool::AddThreads(1);
TimeoutTask::Initialize();
Socket::StartThread();
UInt32 inAddr = SocketUtils::ConvertStringToAddr(broadcastParms->mDestAddress);
UInt16 inPort = atoi(broadcastParms->mRTSPPort);
char * theURL = new char[512];
StringTranslator::EncodeURL(broadcastParms->mDestSDPFile, strlen(broadcastParms->mDestSDPFile) + 1, theURL, 512);
BroadcasterSession::BroadcasterType inBroadcasterType;
if (sPushOverTCP)
inBroadcasterType = BroadcasterSession::kRTSPTCPBroadcasterType;
else
inBroadcasterType = BroadcasterSession::kRTSPUDPBroadcasterType;
UInt32 inDurationInSec = 0;
UInt32 inStartPlayTimeInSec = 0;
UInt32 inRTCPIntervalInSec = 5;
UInt32 inOptionsIntervalInSec = 0;
UInt32 inHTTPCookie = 1;
Bool16 inAppendJunkData = false;
UInt32 inReadInterval = 50;
UInt32 inSockRcvBufSize = 32768;
StrPtrLen sdpSPL(sSDPBuffer,maxSDPbuffSize);
sRTSPClientError = QTFileBroadcaster::eNetworkConnectionError;
sBroadcasterSession = NEW BroadcasterSession(inAddr,
inPort,
theURL,
inBroadcasterType, // Client type
inDurationInSec, // Movie length
inStartPlayTimeInSec, // Movie start time
inRTCPIntervalInSec, // RTCP interval
inOptionsIntervalInSec, // Options interval
inHTTPCookie, // HTTP cookie
inAppendJunkData,
inReadInterval, // Interval between data reads
inSockRcvBufSize,
&sdpSPL,
broadcastParms->mName,
broadcastParms->mPassword,
sDeepDebug,
sBurst);
return sBroadcasterSession;
}
Bool16 AnnounceBroadcast(PLBroadcastDef *broadcastParms,QTFileBroadcaster *fileBroadcasterPtr)
{ // return true if no Announce required or broadcast is ok.
if (!sAnnounceBroadcast) return true;
// if the address is a multicast address then we can't announce the broadcast.
if(SocketUtils::IsMulticastIPAddr(ntohl(inet_addr(broadcastParms->mDestAddress)))) {
sAnnounceBroadcast = false;
return true;
}
#if !MACOSXEVENTQUEUE
::select_startevents();//initialize the select() implementation of the event queue
#endif
if (SocketUtils::GetNumIPAddrs() == 0)
{
qtss_printf("IP must be enabled to run PlaylistBroadcaster\n");
//::exit(0); // why exit here? If we return false here, the calling function will take care of the error
return false;
}
broadcastParms->mTheSession = sBroadcasterSession = StartBroadcastRTSPSession(broadcastParms);
while (!sBroadcasterSession->IsDone() && BroadcasterSession::kBroadcasting != sBroadcasterSession->GetState())
{ OSThread::Sleep(100);
}
sRTSPClientError = 0;
int broadcastErr = sBroadcasterSession->GetRequestStatus();
Bool16 isOK = false;
if (broadcastErr != 200) do
{
if (412 == broadcastErr)
{
::EvalBroadcasterErr(broadcastErr);
break;
}
if (200 != broadcastErr)
{ //qtss_printf("broadcastErr = %"_S32BITARG_" sBroadcasterSession->GetDeathState()=%"_S32BITARG_" sBroadcasterSession->GetReasonForDying()=%"_S32BITARG_"\n",broadcastErr,sBroadcasterSession->GetDeathState(),sBroadcasterSession->GetReasonForDying());
if (sBroadcasterSession->GetDeathState() == BroadcasterSession::kSendingAnnounce && sBroadcasterSession->GetReasonForDying() == BroadcasterSession::kConnectionFailed)
::EvalBroadcasterErr(QTFileBroadcaster::eNetworkConnectionError);
else if (sBroadcasterSession->GetDeathState() == BroadcasterSession::kSendingAnnounce && sBroadcasterSession->GetReasonForDying() == BroadcasterSession::kBadSDP)
::EvalBroadcasterErr(QTFileBroadcaster::eSDPFileInvalid);
else if (401 == broadcastErr)
::EvalBroadcasterErr(QTFileBroadcaster::eNetworkAuthorization);
else if ((500 == broadcastErr) || (400 == broadcastErr) )
::EvalBroadcasterErr(QTFileBroadcaster::eNetworkNotSupported);
else
::EvalBroadcasterErr(QTFileBroadcaster::eNetworkRequestError);
break;
}
if (sBroadcasterSession != NULL && BroadcasterSession::kDiedNormally != sBroadcasterSession->GetReasonForDying())
{ ::EvalBroadcasterErr(QTFileBroadcaster::eNetworkRequestError);
break;
}
isOK = true;
} while (false);
else
isOK = true;
if (isOK)
{
broadcastErr = fileBroadcasterPtr->SetUp(broadcastParms, &sQuitImmediate);
if ( broadcastErr )
{ ::EvalBroadcasterErr(broadcastErr);
qtss_printf( "- Broadcaster setup failed.\n" );
isOK = false;
if (sBroadcasterSession != NULL && !sBroadcasterSession->IsDone())
sBroadcasterSession->TearDownNow();
}
}
return isOK;
}
char* GetBroadcastDirPath(const char * setupFilePath)
{
int len = 2;
if (setupFilePath != NULL)
len = ::strlen(setupFilePath);
char *setupDirPath = new char [ len + 1 ];
if ( setupDirPath )
{
strcpy( setupDirPath, setupFilePath );
char* endOfDirPath = strrchr( setupDirPath, kPathDelimiterChar );
if ( endOfDirPath )
{
endOfDirPath++;
*endOfDirPath= 0;
int chDirErr = ::chdir( setupDirPath );
if ( chDirErr )
chDirErr = errno;
//qtss_printf("- PLB DEBUG MSG: setupDirPath==%s\n chdir err: %i\n", setupDirPath, chDirErr);
}
else
{
setupDirPath[0] = '.';
setupDirPath[1] = kPathDelimiterChar;
setupDirPath[2] = 0;
}
}
//qtss_printf("GetBroadcastDirPath setupDirPath = %s\n",setupDirPath);
return setupDirPath;
}
void CreateCurrentAndUpcomingFiles(PLBroadcastDef* broadcastParms)
{
if (!::strcmp(broadcastParms->mShowCurrent, "enabled"))
{ if(FileCreateAndCheckAccess(broadcastParms->mCurrentFile))
{ /* error */
sgLogger->LogInfo( "PlaylistBroadcaster Error: Failed to create current broadcast file" );
}
}
if (!::strcmp(broadcastParms->mShowUpcoming, "enabled"))
{ if(FileCreateAndCheckAccess(broadcastParms->mUpcomingFile))
{ /* error */
sgLogger->LogInfo( "PlaylistBroadcaster Error: Failed to create upcoming broadcast file" );
}
}
}
void UpdatePlaylistFiles(PLBroadcastDef* broadcastParms, PlaylistPicker *picker,PlaylistPicker *insertPicker)
{
if ( (NULL == broadcastParms)
|| (NULL == picker)
|| (NULL == insertPicker)
) return;
if(!access(broadcastParms->mStopFile, R_OK))
{
picker->CleanList();
PopulatePickerFromFile(picker, broadcastParms->mStopFile, "", NULL);
sTempPicker->CleanList();
remove(broadcastParms->mStopFile);
picker->mStopFlag = true;
}
/* if .replacelist file exists - replace current playlist */
if(!access(broadcastParms->mReplaceFile, R_OK))
{
picker->CleanList();
PopulatePickerFromFile(picker, broadcastParms->mReplaceFile, "", NULL);
sTempPicker->CleanList();
remove(broadcastParms->mReplaceFile);
picker->mStopFlag = false;
}
/* if .insertlist file exists - insert into current playlist */
if(!access(broadcastParms->mInsertFile, R_OK))
{
insertPicker->CleanList();
sTempPicker->CleanList();
PopulatePickerFromFile(insertPicker, broadcastParms->mInsertFile, "", NULL);
remove(broadcastParms->mInsertFile);
picker->mStopFlag = false;
}
// write upcoming playlist to .upcoming file
if (!::strcmp(broadcastParms->mShowUpcoming, "enabled"))
{
FILE *upcomingFile = fopen(broadcastParms->mUpcomingFile, "w");
if(upcomingFile)
{
sElementCount = 0;
if (!::strcmp(broadcastParms->mPlayMode, "weighted_random"))
qtss_fprintf(upcomingFile,"#random play - upcoming list not supported\n");
else
{ qtss_fprintf(upcomingFile,"*PLAY-LIST*\n");
ShowPlaylistElements(insertPicker,upcomingFile);
ShowPlaylistElements(picker,upcomingFile);
if ( picker->GetNumMovies() == 0
&& !picker->mStopFlag
&& 0 != ::strcmp(broadcastParms->mPlayMode, "sequential")
)
{ picker->CleanList();
PopulatePickerFromFile(picker,broadcastParms->mPlayListFile,"",NULL);
ShowPlaylistElements(picker,upcomingFile);
sTempPicker->CleanList();
PopulatePickerFromFile(sTempPicker,broadcastParms->mPlayListFile,"",NULL);
}
if ( sElementCount <= sMaxUpcomingListSize
&& 0 == ::strcmp(broadcastParms->mPlayMode, "sequential_looped")
)
{ if (sTempPicker->GetNumMovies() == 0)
{ sTempPicker->CleanList();
PopulatePickerFromFile(sTempPicker,broadcastParms->mPlayListFile,"",NULL);
}
//sElementCount can be zero if the playlist contains no paths to valid files
while ( (sElementCount != 0) && sElementCount <= sMaxUpcomingListSize )
ShowPlaylistElements(sTempPicker,upcomingFile);
}
}
fclose(upcomingFile);
}
}
else
{
if ( picker->GetNumMovies() == 0
&& !picker->mStopFlag
&& ::strcmp(broadcastParms->mPlayMode, "sequential")
)
{ picker->CleanList();
PopulatePickerFromFile(picker,broadcastParms->mPlayListFile,"",NULL);
}
}
}
void UpdateCurrentFile(PLBroadcastDef* broadcastParms, char *thePick)
{
if ( (NULL == broadcastParms) || (NULL == thePick) )
return;
// save currently playing song to .current file
if (!::strcmp(broadcastParms->mShowCurrent, "enabled"))
{ FILE *currentFile = fopen(broadcastParms->mCurrentFile, "w");
if(currentFile)
{
if (sSetupDirPath.EqualIgnoreCase(thePick, sSetupDirPath.Len) || '\\' == thePick[0] || '/' == thePick[0])
qtss_fprintf(currentFile,"u=%s\n",thePick);
else
qtss_fprintf(currentFile,"u=%s%s\n", sSetupDirPath.Ptr,thePick);
fclose(currentFile);
}
}
}
static void PreFlightOrBroadcast( const char *bcastSetupFilePath, bool preflight, bool daemonize, bool showMovieList, bool writeCurrentMovieFile, char *destinationIP,bool writeNewSDP, const char* errorFilePath)
{
PLBroadcastDef* broadcastParms = NULL;
PlaylistPicker* picker = NULL;
PlaylistPicker* insertPicker = NULL;
QTFileBroadcaster fileBroadcaster;
int broadcastErr = 0;
SInt32 moviePlayCount;
char* thePick = NULL;
int numMovieErrors;
bool didAtLeastOneMoviePlay = false;
bool sdpFileCreated = false;
char *allocatedIPStr = NULL;
bool generateNewSDP = false;
int numErrorsBeforeSDPGen = 0;
char theUserAgentStr[128];
char* thePLBStr = "PlaylistBroadcaster";
RegisterEventHandlers();
if ( !PreFlightSetupFile( bcastSetupFilePath ) ) // returns true on success and false on failure
{
sNumErrors++;
goto bail;
}
if (destinationIP != NULL)
{
allocatedIPStr = new char[strlen(destinationIP)+1];
strcpy(allocatedIPStr,destinationIP);
generateNewSDP = true;
}
broadcastParms = new PLBroadcastDef( bcastSetupFilePath, allocatedIPStr, sDeepDebug);
sBroadcastParms = broadcastParms;
if( !broadcastParms )
{
qtss_printf("- PlaylistBroadcaster: Error. Out of memory.\n" );
sNumErrors++;
goto bail;
}
if ( !broadcastParms->ParamsAreValid() )
{
qtss_printf("- PlaylistBroadcaster: Error reading the broadcast description file \"%s\". (bad format or missing file)\n", bcastSetupFilePath );
broadcastParms->ShowErrorParams();
sNumErrors++;
goto bail;
}
if ( preflight || sDeepDebug)
ShowSetupParams(broadcastParms, bcastSetupFilePath);
if (NULL == GetBroadcastDirPath(bcastSetupFilePath))
{
qtss_printf("- PlaylistBroadcaster: Error. Out of memory.\n" );
sNumErrors++;
goto bail;
}
sSetupDirPath.Set(GetBroadcastDirPath(bcastSetupFilePath), strlen(GetBroadcastDirPath(bcastSetupFilePath)));
if (preflight)
{
picker = new PlaylistPicker(false); // make sequential picker, no looping
}
else
{
picker = MakePickerFromConfig( broadcastParms ); // make picker according to parms
sTempPicker = new PlaylistPicker(false);
insertPicker = new PlaylistPicker(false);
insertPicker->mRemoveFlag = true;
}
if ( !picker )
{
qtss_printf("- PlaylistBroadcaster: Error. Out of memory.\n" );
sNumErrors++;
goto bail;
}
if ( preflight || sDeepDebug)
qtss_printf("\n");
Assert( broadcastParms->mPlayListFile );
if ( broadcastParms->mPlayListFile )
{
char* fileName;
fileName = broadcastParms->mPlayListFile;
// initial call uses empty string for path, NULL for loop detection list
(void)PopulatePickerFromFile( picker, fileName, "", NULL );
// ignore errors, if we have movies in the list, play them
}
if ( preflight )
{
if ( picker->mNumToPickFrom == 1 )
qtss_printf( "\nThere is (%li) movie in the Playlist.\n\n", (SInt32) picker->mNumToPickFrom );
else
qtss_printf( "\nThere are (%li) movies in the Playlist.\n\n", (SInt32) picker->mNumToPickFrom );
}
if ( !picker->mNumToPickFrom )
{
qtss_printf( "- PlaylistBroadcaster setup failed: There are no movies to play.\n" );
sNumErrors++;
goto bail;
}
// check that we have enough movies to cover the recent movies list.
if ( preflight && broadcastParms->ParamsAreValid() )
{
if ( !strcmp( broadcastParms->mPlayMode, "weighted_random" ) ) // this implies "random" play
{
if ( broadcastParms->mLimitPlayQueueLength >= picker->mNumToPickFrom )
{
broadcastParms->mLimitPlayQueueLength = picker->mNumToPickFrom-1;
qtss_printf("- PlaylistBroadcaster Warning:\n The recent_movies_list_size setting is greater than \n");
qtss_printf(" or equal to the number of movies in the playlist.\n" );
}
}
}
// create the log file
sgLogger = new BroadcastLog( broadcastParms, &sSetupDirPath );
Assert( sgLogger != NULL );
if( sgLogger == NULL )
{
qtss_printf("- PlaylistBroadcaster: Error. Out of memory.\n" );
sNumErrors++;
goto bail;
}
numErrorsBeforeSDPGen = sNumErrors;
sdpFileCreated = DoSDPGen( broadcastParms, preflight, writeNewSDP,generateNewSDP, &sNumErrors, picker->GetFirstFile());
if( sNumErrors > numErrorsBeforeSDPGen )
goto bail;
if (!sAnnounceBroadcast)
broadcastErr = fileBroadcaster.SetUp(broadcastParms, &sQuitImmediate);
if ( broadcastErr )
{
::EvalBroadcasterErr(broadcastErr);
qtss_printf( "- Broadcaster setup failed.\n" );
sNumErrors++;
goto bail;
}
if (preflight)
{
fileBroadcaster.fPlay = false;
}
if ( !PreflightTrackerFileAccess( R_OK | W_OK ) )
{
sNumErrors++;
goto bail;
}
//Unless the Debug command line option is set, daemonize the process at this point
if (daemonize)
{
#ifndef __Win32__
qtss_printf("- PlaylistBroadcaster: Started in background.\n");
// keep the same working directory..
if (::daemon( 1, 0 ) != 0)
{
qtss_printf("- PlaylistBroadcaster: System error (%i).\n", errno);
goto bail;
}
#endif //__Win32__
}
// If daemonize, then reopen stdout to the error file
if (daemonize && (errorFilePath != NULL))
{
freopen(errorFilePath, "a", stdout);
::setvbuf(stdout, (char *)NULL, _IONBF, 0);
}
#ifndef __Win32__
qtss_snprintf(theUserAgentStr, ::strlen(thePLBStr) + 1 + ::strlen(kVersionString) + 1, "%s/%s", thePLBStr, kVersionString);
#else
_snprintf(theUserAgentStr, ::strlen(thePLBStr) + 1 + ::strlen(kVersionString) + 1, "%s/%s", thePLBStr, kVersionString);
#endif
RTSPClient::SetUserAgentStr(theUserAgentStr);
if (!preflight && !AnnounceBroadcast(broadcastParms,&fileBroadcaster))
{
sNumErrors++;
goto bail;
}
// ^ daemon must be called before we Open the log and tracker since we'll
// get a new pid, our files close, ( does SIGTERM get sent? )
if (( sgLogger != NULL ) && ( sgLogger->WantsLogging() ))
sgLogger->EnableLog( false ); // don't append ".log" to name for PLB
if ( sgLogger->WantsLogging() && !sgLogger->IsLogEnabled() )
{
if ( sgLogger->LogDirName() && *sgLogger->LogDirName() )
qtss_printf("- PlaylistBroadcaster: The log file failed to open.\n ( path: %s/%s )\n Exiting.\n", sgLogger->LogDirName(), sgLogger->LogFileName() );
else
qtss_printf("- PlaylistBroadcaster: The log file failed to open.\n ( path: %s )\n Exiting.\n", sgLogger->LogFileName() );
sNumErrors++;
goto bail;
}
if (broadcastParms->mPIDFile != NULL)
{
if(!FileCreateAndCheckAccess(broadcastParms->mPIDFile))
{
FILE *pidFile = fopen(broadcastParms->mPIDFile, "w");
if(pidFile)
{
qtss_fprintf(pidFile,"%d\n",getpid());
fclose(pidFile);
}
}
}
else if ( !AddOurPIDToTracker( bcastSetupFilePath ) ) // <-- doesn't exit on failure anymore - returns false if failed
{
// writes to the broadcast list file only if the pid_file config param doesn't exist
sNumErrors++;
goto bail;
}
if ( !preflight )
sgLogger->LogInfo( "PlaylistBroadcaster started." );
else
sgLogger->LogInfo( "PlaylistBroadcaster preflight started." );
//+ make the RTP movie broadcaster
if ( !preflight )
{
qtss_printf( "\n" );
qtss_printf( "[pick#] movie path\n" );
qtss_printf( "----------------------------\n" );
}
else
{
qtss_printf( "\n" );
qtss_printf( "Problems found\n" );
qtss_printf( "--------------\n" );
}
if(!preflight)
CreateCurrentAndUpcomingFiles(broadcastParms);
moviePlayCount = 0;
numMovieErrors = 0;
didAtLeastOneMoviePlay = false;
sMaxUpcomingListSize = ::atoi( broadcastParms->mMaxUpcomingMovieListSize );
while (true)
{
if (!showMovieList && !preflight)
{
UpdatePlaylistFiles(broadcastParms, picker, insertPicker);
}
if (NULL != insertPicker)
thePick = insertPicker->PickOne();
if (NULL == thePick && (NULL != picker))
thePick = picker->PickOne();
if ( (thePick != NULL) && (!preflight || showMovieList) )
{
// display the picks in debug mode, but not preflight
qtss_printf( "[%li] ", moviePlayCount );
{
if (sSetupDirPath.EqualIgnoreCase(thePick, sSetupDirPath.Len) || '\\' == thePick[0] || '/' == thePick[0])
qtss_printf("%s picked\n", thePick);
else
qtss_printf("%s%s picked\n", sSetupDirPath.Ptr,thePick);
}
}
if ( !showMovieList )
{
int playError;
if(!preflight)
{ UpdateCurrentFile(broadcastParms, thePick);
/* if playlist is about to run out repopulate it */
if ( !::strcmp(broadcastParms->mPlayMode, "sequential_looped") )
{
if(NULL == thePick &&!picker->mStopFlag)
{
if (picker->GetNumMovies() == 0)
break;
else
continue;
}
}
}
if (thePick == NULL)
break;
++moviePlayCount;
if(!preflight)
{
SInt64 startTime = OS::Milliseconds();
SInt64 endTime = 0;
playError = fileBroadcaster.PlayMovie( thePick, broadcastParms->mCurrentFile );
endTime = OS::Milliseconds();
//were we able to actually play the movie?
didAtLeastOneMoviePlay = didAtLeastOneMoviePlay || (playError == 0);
//ok, we've reached the end of the current playlist
if (picker->GetNumMovies() == 0)
{
//If we determine that every one of the movies resulted in an error, then bail
if (!didAtLeastOneMoviePlay)
{
qtss_printf("Quitting: Playlist contains no valid files.\n");
sgLogger->LogInfo( "Quitting: Playlist contains no valid files.\n" );
goto bail;
}
else
{
didAtLeastOneMoviePlay = false;
}
}
// log the result of broacasting the picked movie
sgLogger->LogMediaData( thePick,
fileBroadcaster.fCurrentMovieName,
fileBroadcaster.fCurrentMovieCopyright,
fileBroadcaster.fCurrentMovieComment,
fileBroadcaster.fCurrentMovieAuthor,
fileBroadcaster.fCurrentMovieArtist,
fileBroadcaster.fCurrentMovieAlbum,
(UInt32) ((endTime - startTime)/1000L),
playError);
}
else
{
playError = fileBroadcaster.PlayMovie( thePick, NULL );
}
if (sQuitImmediate)
{
break;
}
if (sBroadcasterSession != NULL && sBroadcasterSession->GetReasonForDying() != BroadcasterSession::kDiedNormally)
{
playError = ::EvalBroadcasterErr(QTFileBroadcaster::eNetworkConnectionFailed);
sNumErrors++;
goto bail;
}
if ( playError == 0 && sAnnounceBroadcast)
{
int theErr = sBroadcasterSession->GetRequestStatus();
if (200 != theErr)
{
if (401 == theErr)
playError = QTFileBroadcaster::eNetworkAuthorization;
else if (500 == theErr)
playError = QTFileBroadcaster::eNetworkNotSupported;
else
playError = QTFileBroadcaster::eNetworkConnectionError;
sNumErrors++;
goto bail;
}
}
if (playError)
{
playError = ::EvalBroadcasterErr(playError);
if (playError == QTFileBroadcaster::eNetworkConnectionError)
goto bail;
qtss_printf(" (file: %s err: %d %s)\n", thePick, playError,GetMovieFileErrString( playError ) );
sNumWarnings++;
numMovieErrors++;
}
else
{
int tracks = fileBroadcaster.GetMovieTrackCount() ;
int mtracks = fileBroadcaster.GetMappedMovieTrackCount();
if (tracks != mtracks)
{
sNumWarnings++;
numMovieErrors++;
qtss_printf("- PlaylistBroadcaster: Warning, movie tracks do not match the SDP file.\n" );
qtss_printf(" Movie: %s .\n", thePick );
qtss_printf(" %i of %i hinted tracks will not broadcast.\n", tracks- mtracks, tracks );
}
}
if ( !preflight && (playError != 0) )
sgLogger->LogMediaError( thePick, GetMovieFileErrString( playError ),NULL );
}
delete [] thePick;
thePick = NULL;
} //while (true)
remove(broadcastParms->mCurrentFile);
remove(broadcastParms->mUpcomingFile);
if ( preflight )
{
char str[256];
qtss_printf( " - " );
if (numMovieErrors == 1)
strcpy(str, "PlaylistBroadcaster found one problem movie file.");
else
qtss_sprintf( str, "PlaylistBroadcaster found %d problem movie files." , numMovieErrors );
qtss_printf( "%s\n", str );
if (sgLogger != NULL)
sgLogger->LogInfo( str );
if (numMovieErrors == moviePlayCount)
{
qtss_printf("There are no valid movies to play\n");
sNumErrors++;
}
}
if (NULL != sBroadcasterSession && !sBroadcasterSession->IsDone() )
{ sErrorEvaluted = true;
}
bail:
Cleanup();
delete picker;
sBroadcastParms = NULL;
delete broadcastParms;
if ( !preflight )
{
if (sgLogger != NULL)
{ if (!sQuitImmediate)
sgLogger->LogInfo( "PlaylistBroadcaster finished." );
else
sgLogger->LogInfo( "PlaylistBroadcaster stopped." );
}
if (!sQuitImmediate) // test sQuitImmediate again
qtss_printf( "\nPlaylistBroadcaster broadcast finished.\n" );
else
qtss_printf( "\nPlaylistBroadcaster broadcast stopped.\n" );
}
else
{
if (sgLogger != NULL)
{ if (!sQuitImmediate)
sgLogger->LogInfo( "PlaylistBroadcaster preflight finished." );
else
sgLogger->LogInfo( "PlaylistBroadcaster preflight stopped." );
}
if (!sQuitImmediate) // test sQuitImmediate again
qtss_printf( "\nPlaylistBroadcaster preflight finished.\n" );
else
qtss_printf( "\nPlaylistBroadcaster preflight stopped.\n" );
}
sgLogger = NULL; // protect the interrupt handler and just let it die don't delete because it is a task thread
#ifndef __Win32__
if ( sgTrackingSucceeded )
{
// remove ourselves from the tracker
// this is the "normal" remove, also signal handlers
// may remove us.
BCasterTracker tracker( sgTrackerFilePath );
tracker.RemoveByProcessID( getpid() );
tracker.Save();
}
#endif //__Win32__
if (sBroadcasterSession != NULL && !sBroadcasterSession->IsDone())
{
//qtss_printf("QUIT now sBroadcasterSession->TearDownNow();\n");
sBroadcasterSession->TearDownNow();
int count=0;
while (count++ < 30 && !sBroadcasterSession->IsDone() )
{ sBroadcasterSession->Run();
OSThread::Sleep(100);
}
sBroadcasterSession = NULL;
}
}
static void Cleanup()
{
if (sCleanupDone == true)
return;
sCleanupDone = true;
if (sPreflight)
{
qtss_printf("Warnings: %d\n", sNumWarnings);
qtss_printf("Errors: %d\n", sNumErrors);
}
else
{
qtss_printf("Broadcast Warnings: %d\n", sNumWarnings);
qtss_printf("Broadcast Errors: %d\n", sNumErrors);
}
RemoveFiles(sBroadcastParms);
}
static void version()
{
/*
print PlaylistBroadcaster version and build info
see revision.h
*/
//RoadRunner/2.0.0-v24 Built on: Sep 17 1999 , 16:09:53
//revision.h (project level file) -- include with -i option
qtss_printf("PlaylistBroadcaster/%s Built on: %s, %s\n", kVersionString, __DATE__, __TIME__ );
}
static void usage()
{
/*
print PlaylistBroadcaster usage string
*/
#ifndef __Win32__
qtss_printf("usage: PlaylistBroadcaster [-v] [-h] [-p] [-c] [-a] [-t] [-i destAddress] [-e filename] [-f] [-d] [-l] [-s broadcastNum] filename\n" );
#else
qtss_printf("usage: PlaylistBroadcaster [-v] [-h] [-p] [-c] [-a] [-t] [-i destAddress] [-e filename] [-f] filename\n" );
#endif
qtss_printf(" -v: Display version\n" );
qtss_printf(" -h: Display help\n" );
qtss_printf(" -p: Verify a broadcast description file and movie list.\n" );
qtss_printf(" -c: Show the current movie in the log file.\n" );
qtss_printf(" -a: Announce the broadcast to the server.\n" );
qtss_printf(" -t: Send the broadcast over TCP to the server.\n" );
qtss_printf(" -i: Specify the destination ip address. Over-rides config file value.\n" );
qtss_printf(" -e: Log errors to filename.\n" );
qtss_printf(" -f: Force a new SDP file to be created even if one already exists.\n" );
#ifndef __Win32__
qtss_printf(" -d: Run attached to the terminal.\n" );
qtss_printf(" -l: List running currently broadcasts.\n" );
qtss_printf(" -s: Stop a running broadcast.\n" );
#endif
qtss_printf(" filename: Broadcast description filename.\n" );
}
static void help()
{
/*
print PlaylistBroadcaster help info
*/
::version();
::usage();
qtss_printf("\n\nSample broadcast description file: ");
PLBroadcastDef(NULL,NULL,false);
}
static PlaylistPicker* MakePickerFromConfig( PLBroadcastDef* broadcastParms )
{
// construct a PlaylistPicker object using options set from a PLBroadcastDef
PlaylistPicker *picker = NULL;
if ( broadcastParms && broadcastParms->ParamsAreValid() )
{
if ( broadcastParms->mPlayMode )
{
if ( !::strcmp( broadcastParms->mPlayMode, "weighted_random" ) )
{
int noPlayQueueLen = 0;
noPlayQueueLen = broadcastParms->mLimitPlayQueueLength;
picker = new PlaylistPicker( 10, noPlayQueueLen );
}
else if ( !::strcmp( broadcastParms->mPlayMode, "sequential_looped" ) )
{
picker = new PlaylistPicker(true);
picker->mRemoveFlag = true;
}
else if ( !::strcmp( broadcastParms->mPlayMode, "sequential" ) )
{
picker = new PlaylistPicker(false);
picker->mRemoveFlag = true;
}
}
}
return picker;
}
static const char* GetMovieFileErrString( int err )
{
static char buff[80];
switch ( err )
{
case 0:
break;
case QTFileBroadcaster::eMovieFileNotFound:
return "Movie file not found.";
case QTFileBroadcaster::eMovieFileNoHintedTracks:
return "Movie file has no hinted tracks.";
case QTFileBroadcaster::eMovieFileNoSDPMatches :
return "Movie file does not match SDP.";
case QTFileBroadcaster::eMovieFileInvalid:
return "Movie file is invalid.";
case QTFileBroadcaster::eMovieFileInvalidName:
return "Movie file name is missing or too long.";
default:
qtss_sprintf( buff, "Movie set up error %d occured.",err );
return buff;
}
return NULL;
}
static int sErr = 0;
static int EvalBroadcasterErr(int err)
{
int returnErr = err;
if (sErr != 0)
return sErr;
switch (err)
{ case 412:
{ qtss_printf("- Server Session Failed: The request was denied.");
qtss_printf("\n");
break;
}
case QTFileBroadcaster::eNoAvailableSockets :
case QTFileBroadcaster::eSDPFileNotFound :
case QTFileBroadcaster::eSDPDestAddrInvalid :
case QTFileBroadcaster::eSDPFileInvalid :
case QTFileBroadcaster::eSDPFileNoMedia :
case QTFileBroadcaster::eSDPFileNoPorts :
case QTFileBroadcaster::eSDPFileInvalidPort :
{ qtss_printf("- SDP set up failed: ");
switch( err )
{
case QTFileBroadcaster::eNoAvailableSockets : qtss_printf("System error. No sockets are available to broadcast from.");
break;
case QTFileBroadcaster::eSDPFileNotFound : qtss_printf("The SDP file is missing.");
break;
case QTFileBroadcaster::eSDPDestAddrInvalid : qtss_printf("The SDP file server address is invalid.");
break;
case QTFileBroadcaster::eSDPFileInvalid : qtss_printf("The SDP file is invalid.");
break;
case QTFileBroadcaster::eSDPFileNoMedia : qtss_printf("The SDP file is missing media (m=) references.");
break;
case QTFileBroadcaster::eSDPFileNoPorts : qtss_printf("The SDP file is missing server port information.");
break;
case QTFileBroadcaster::eSDPFileInvalidPort : qtss_printf("The SDP file contains an invalid port. Valid range is 5004 - 65530.");
break;
default: qtss_printf("SDP set up error %d occured.",err);
break;
};
qtss_printf("\n");
}
break;
case QTFileBroadcaster::eSDPFileInvalidTTL:
case QTFileBroadcaster::eDescriptionInvalidDestPort:
case QTFileBroadcaster::eSDPFileInvalidName:
case QTFileBroadcaster::eNetworkSDPFileNameInvalidBadPath:
case QTFileBroadcaster::eNetworkSDPFileNameInvalidMissing:
{ qtss_printf("- Description set up failed: ");
switch( err )
{
case QTFileBroadcaster::eSDPFileInvalidTTL : qtss_printf("The multicast_ttl value is incorrect. Valid range is 1 to 255.");
break;
case QTFileBroadcaster::eDescriptionInvalidDestPort : qtss_printf("The destination_base_port value is incorrect. Valid range is 5004 - 65530.");
break;
case QTFileBroadcaster::eSDPFileInvalidName : qtss_printf("The sdp_file name is missing or too long.");
break;
case QTFileBroadcaster::eNetworkSDPFileNameInvalidBadPath: qtss_printf("The specified destination_sdp_file must a be relative file path in the movies directory.");
break;
case QTFileBroadcaster::eNetworkSDPFileNameInvalidMissing: qtss_printf("The specified destination_sdp_file name is missing.");
break;
default: qtss_printf("Description set up error %d occured.",err);
break;
}
qtss_printf("\n");
}
break;
case QTFileBroadcaster::eMovieFileNotFound :
case QTFileBroadcaster::eMovieFileNoHintedTracks :
case QTFileBroadcaster::eMovieFileNoSDPMatches :
case QTFileBroadcaster::eMovieFileInvalid :
case QTFileBroadcaster::eMovieFileInvalidName :
{ qtss_printf("- Movie set up failed: ");
switch( err )
{
case QTFileBroadcaster::eMovieFileNotFound : qtss_printf("Movie file not found.");
break;
case QTFileBroadcaster::eMovieFileNoHintedTracks : qtss_printf("Movie file has no hinted tracks.");
break;
case QTFileBroadcaster::eMovieFileNoSDPMatches : qtss_printf("Movie file does not match SDP.");
break;
case QTFileBroadcaster::eMovieFileInvalid : qtss_printf("Movie file is invalid.");
break;
case QTFileBroadcaster::eMovieFileInvalidName : qtss_printf("Movie file name is missing or too long.");
break;
default: qtss_printf("Movie set up error %d occured.",err);
break;
};
qtss_printf("\n");
}
break;
case QTFileBroadcaster::eMem:
case QTFileBroadcaster::eInternalError:
{ qtss_printf("- Internal Error: ");
switch( err )
{
case QTFileBroadcaster::eMem : qtss_printf("Memory error.");
break;
case QTFileBroadcaster::eInternalError : qtss_printf("Internal error.");
break;
default: qtss_printf("internal error %d occured.",err);
break;
}
qtss_printf("\n");
}
break;
case QTFileBroadcaster::eFailedBind:
case QTFileBroadcaster::eNetworkConnectionError:
case QTFileBroadcaster::eNetworkRequestError:
case QTFileBroadcaster::eNetworkConnectionStopped:
case QTFileBroadcaster::eNetworkAuthorization:
case QTFileBroadcaster::eNetworkNotSupported:
case QTFileBroadcaster::eNetworkConnectionFailed:
{ sErrorEvaluted = true;
qtss_printf("- Network Connection: ");
switch( err )
{
case QTFileBroadcaster::eFailedBind : qtss_printf("A Socket failed trying to open and bind to a local port.\n.");
break;
case QTFileBroadcaster::eNetworkConnectionError : qtss_printf("Failed to connect.");
break;
case QTFileBroadcaster::eNetworkRequestError : qtss_printf("Server returned error.");
break;
case QTFileBroadcaster::eNetworkConnectionStopped: qtss_printf("Connection stopped.");
break;
case QTFileBroadcaster::eNetworkAuthorization: qtss_printf("Authorization failed.");
break;
case QTFileBroadcaster::eNetworkNotSupported: qtss_printf("Connection not supported by server.");
break;
case QTFileBroadcaster::eNetworkConnectionFailed : qtss_printf("Disconnected.");
break;
default: qtss_printf("internal error %d occured.",err);
break;
}
qtss_printf("\n");
returnErr = QTFileBroadcaster::eNetworkConnectionError;
}
break;
default:
break;
}
sErr = returnErr;
return returnErr;
}
static int MyAccess( const char* path, int mode )
{
int error = 0;
#ifndef __Win32__
if ( access( path, mode ) )
error = errno;
else
error = 0;
#endif
return error;
}
static int PreflightClientBufferDelay( const char * delay, Float32 *ioDelay)
{
int numPreflightErrors = 0;
if ( NULL == delay|| 0 == delay[0] )
numPreflightErrors++;
else
{ Float32 delayValue = 0.0;
::sscanf(delay, "%f", &delayValue);
if (delayValue < 0.0)
numPreflightErrors++;
if (ioDelay != NULL)
*ioDelay = delayValue;
}
if (numPreflightErrors > 0)
qtss_printf("- PlaylistBroadcaster: The client_buffer_delay parameter is invalid.\n" );
return numPreflightErrors;
}
static int PreflightDestSDPFileAccess( const char * sdpPath )
{
int numPreflightErrors = 0;
if ( NULL == sdpPath || 0==sdpPath[0] || 0 == ::strcmp(sdpPath, "no_name") )
{ qtss_printf("- PlaylistBroadcaster: The destination_sdp_file parameter is missing from the Broadcaster description file.\n" );
numPreflightErrors++;
}
return numPreflightErrors;
}
static int PreflightSDPFileAccess( const char * sdpPath )
{
int numPreflightErrors = 0;
Assert( sdpPath );
if ( !sdpPath )
{ qtss_printf("- PlaylistBroadcaster: The sdp_file parameter is missing from the Broadcaster description file.\n" );
numPreflightErrors++;
}
else
{ int accessError;
accessError = MyAccess( sdpPath, R_OK | W_OK );
switch( accessError )
{
case 0:
case ENOENT: // if its not there, we'll create it
break;
case EACCES:
qtss_printf("- PlaylistBroadcaster: Permission to access the SDP File was denied.\n Read/Write access is required.\n (path: %s, errno: %i).\n", sdpPath, accessError);
numPreflightErrors++;
break;
default:
qtss_printf("- PlaylistBroadcaster: Unable to access the SDP File.\n (path: %s, errno: %i).\n", sdpPath, accessError);
numPreflightErrors++;
break;
}
}
return numPreflightErrors;
}
static int PreflightDestinationAddress( const char *destAddress )
{
int numPreflightErrors = 0;
if ( !destAddress || (SocketUtils::ConvertStringToAddr(destAddress) == INADDR_NONE) )
{ qtss_printf("- PlaylistBroadcaster: Error, desitination_ip_address parameter missing or incorrect in the Broadcaster description file.\n" );
numPreflightErrors++;
}
return numPreflightErrors;
}
static int PreflightBasePort( const char *basePort )
{
int numPreflightErrors = 0;
Assert( basePort );
if ( basePort == NULL )
{ qtss_printf("- PlaylistBroadcaster: Error, destination_base_port parameter missing from the Broadcaster description file.\n" );
numPreflightErrors++;
}
else if ( (atoi(basePort) & 1) != 0)
{
qtss_printf("- PlaylistBroadcaster: Warning, the destination_base_port parameter(%s) is an odd port number. It should be even.\n", basePort );
}
return numPreflightErrors;
}
static int PreflightReferenceMovieAccess( const char *refMoviePath )
{
int numPreflightErrors = 0;
Assert( refMoviePath );
if ( !refMoviePath )
{ qtss_printf("- PlaylistBroadcaster: Error, sdp_reference_movie parameter missing from the Broadcaster description file.\n" );
numPreflightErrors++;
}
else
{ int accessError;
accessError = MyAccess( refMoviePath, R_OK );
switch( accessError )
{
case 0:
break;
case ENOENT:
qtss_printf("- PlaylistBroadcaster: Error, SDP Reference Movie is missing.\n (path: %s, errno: %i).\n", refMoviePath, accessError);
numPreflightErrors++;
break;
case EACCES:
qtss_printf("- PlaylistBroadcaster: Permission to access the SDP reference movie was denied.\n Read access required.\n (path: %s, errno: %i).\n", refMoviePath, accessError);
numPreflightErrors++;
break;
default:
qtss_printf("- PlaylistBroadcaster: Unable to access the SDP reference movie.\n (path: %s, errno: %i).\n", refMoviePath, accessError);
numPreflightErrors++;
break;
}
}
return numPreflightErrors;
}
static void ShowPlaylistStatus()
{
#ifndef __Win32__
BCasterTracker tracker( sgTrackerFilePath );
if ( tracker.IsOpen() )
{
tracker.Show();
}
else
{
qtss_printf("- PlaylistBroadcaster: Could not open %s. Reason: access denied.\n", sgTrackerFilePath );
qtss_printf("- PlaylistBroadcaster: Change user or change the directory's privileges to access %s.\n",sgTrackerFilePath) ;
::exit(-1);
}
#else
qtss_printf("Showing Playlist status is currently not supported on this platform\n");
#endif
}
static void StopABroadcast( const char* arg )
{
#ifndef __Win32__
if ( arg )
{
BCasterTracker tracker( sgTrackerFilePath );
int playlistIDToKill;
playlistIDToKill = ::atoi( arg );
playlistIDToKill--; // convert from UI one based to to zero based ID for BCasterTracker
if ( tracker.IsOpen() )
{
bool broadcastIDIsValid;
int error;
error = tracker.Remove( playlistIDToKill );
if ( !error ) // remove the xth item from the list.
{ tracker.Save();
broadcastIDIsValid = true;
}
else
broadcastIDIsValid = false;
if ( !broadcastIDIsValid )
{
if ( playlistIDToKill >= 0 )
{
if ( error == ESRCH || error == -1 )
qtss_printf( "- PlaylistBroadcaster Broadcast ID (%s) not running.\n", arg );
else
qtss_printf( "- PlaylistBroadcaster Broadcast ID (%s), permission to stop denied (%i).\n", arg, error );
}
else
{ qtss_printf( "- Bad argument for stop: (%s).\n", arg );
::exit( -1 );
}
}
else
qtss_printf("PlaylistBroadcaster stopped Broadcast ID: %s.\n", arg);
}
else
{ qtss_printf("- PlaylistBroadcaster: Could not open %s. Reason: access denied.\n", sgTrackerFilePath );
qtss_printf("- PlaylistBroadcaster: Change user or change the directory's privileges to access %s.\n",sgTrackerFilePath) ;
::exit( -1 );
}
}
else
{ // getopt will catch this problem before we see it.
qtss_printf("- Stop requires a Broadcast ID.\n");
::exit( -1 );
}
#else
qtss_printf("Stopping a broadcast is currently not supported on this platform\n");
#endif
}
static bool DoSDPGen( PLBroadcastDef *broadcastParms, bool preflight, bool overWriteSDP, bool generateNewSDP, int* numErrorsPtr, char* refMovie)
{
int numSDPSetupErrors = 0;
bool sdpFileCreated = false;
if (sAnnounceBroadcast)
{ numSDPSetupErrors += PreflightDestSDPFileAccess( broadcastParms->mDestSDPFile );
Assert(broadcastParms->mBasePort != NULL);
Assert(broadcastParms->mBasePort[0]!=0);
broadcastParms->mBasePort[0] = '0';//set to dynamic. ignore any defined.
broadcastParms->mBasePort[1] = 0;
}
if (broadcastParms->mSDPReferenceMovie != NULL)
refMovie = broadcastParms->mSDPReferenceMovie;
qtss_printf("Ref Movie = %s\n", refMovie);
qtss_printf("SDP file = %s\n", broadcastParms->mSDPFile);
numSDPSetupErrors += PreflightSDPFileAccess( broadcastParms->mSDPFile );
numSDPSetupErrors += PreflightReferenceMovieAccess( refMovie );
numSDPSetupErrors += PreflightDestinationAddress( broadcastParms->mDestAddress );
numSDPSetupErrors += PreflightBasePort( broadcastParms->mBasePort );
Float32 bufferDelay = 0.0;
numSDPSetupErrors += PreflightClientBufferDelay( broadcastParms->mClientBufferDelay,&bufferDelay );
if ( numSDPSetupErrors == 0 )
{
SDPGen* sdpGen = new SDPGen;
int sdpResult = -1;
Assert( sdpGen );
if ( sdpGen )
{
sdpGen->SetClientBufferDelay(bufferDelay); // sdp "a=x-bufferdelay: value"
sdpGen->KeepSDPTracks(false); // set this to keep a=control track ids if we are going to ANNOUNCE the sdp to the server.
sdpGen->AddIndexTracks(true); // set this if KeepTracks is false and to ANNOUNCE the sdp to the server.
sdpResult = sdpGen->Run( refMovie, broadcastParms->mSDPFile,
broadcastParms->mBasePort, broadcastParms->mDestAddress,
sSDPBuffer, maxSDPbuffSize,
overWriteSDP, generateNewSDP,
broadcastParms->mStartTime,
broadcastParms->mEndTime,
broadcastParms->mIsDynamic,
broadcastParms->mTTL
);
sdpFileCreated = sdpGen->fSDPFileCreated;
if ( sdpGen->fSDPFileCreated && !preflight)
qtss_printf( "- PlaylistBroadcaster: Created SDP file.\n (path: %s)\n", broadcastParms->mSDPFile);
}
if ( sdpResult )
{
if (sdpResult == -2)
qtss_printf("- SDP generation failed: Unable to create the SDP File.\n (path: %s, errno: %d).\n", broadcastParms->mSDPFile, sdpResult);
else
qtss_printf( "- SDP generation failed (error: %li).\n", (SInt32)sdpResult );
(*numErrorsPtr)++;
return sdpFileCreated;
}
if ( sdpGen )
delete sdpGen;
sdpGen = NULL;
}
else
{ qtss_printf( "- PlaylistBroadcaster: Too many SDP set up errors, exiting.\n" );
*numErrorsPtr += numSDPSetupErrors;
}
return sdpFileCreated;
}
static bool PreflightTrackerFileAccess( int mode )
{
#ifndef __Win32__
int trackerError;
int dirlen = strlen(sgTrackerDirPath) + 1;
OSCharArrayDeleter trackDir(new char[dirlen]);
char *trackDirPtr = trackDir.GetObject();
::memcpy(trackDirPtr, sgTrackerDirPath, dirlen);
trackerError= OS::RecursiveMakeDir( trackDirPtr );
if ( trackerError == 0 )
trackerError = MyAccess( sgTrackerFilePath, mode );
switch ( trackerError )
{
case 0:
case ENOENT:
break;
default:
qtss_printf("- PlaylistBroadcaster: Error opening %s. (errno: %i).\n", sgTrackerFilePath, trackerError);
qtss_printf("- PlaylistBroadcaster: Change user or change the directory's privileges to access %s.\n",sgTrackerFilePath) ;
return false;
break;
}
#endif
return true;
}
static void ShowSetupParams(PLBroadcastDef* broadcastParms, const char *bcastSetupFilePath)
{
qtss_printf( "\n" );
qtss_printf( "PlaylistBroadcaster broadcast description File\n" );
qtss_printf( "----------------------------------------------\n" );
qtss_printf( "%s\n", bcastSetupFilePath );
broadcastParms->ShowSettings();
}
static bool PreFlightSetupFile( const char * bcastSetupFilePath )
{
bool success = true;
// now complain!
if ( !bcastSetupFilePath )
{ qtss_printf("- PlaylistBroadcaster: A broadcast description file is required.\n" );
::usage();
success = false;
}
else if (::strlen(bcastSetupFilePath) > PLBroadcastDef::kMaxBufferStringLen)
{ qtss_printf("- PlaylistBroadcaster: A broadcast description file path cannot be longer than %d in length.\n",PLBroadcastDef::kMaxBufferStringLen );
::usage();
success = false;
}
else
{ int accessError;
accessError = MyAccess(bcastSetupFilePath, R_OK );
switch( accessError )
{
case 0:
break;
case ENOENT:
qtss_printf("- PlaylistBroadcaster: The broadcast description file is missing.\n (path: %s, errno: %i).\n", bcastSetupFilePath, accessError);
success = false;
break;
case EACCES:
qtss_printf("- PlaylistBroadcaster: Permission denied to access the broadcast description file.\n Read access required.\n (path: %s, errno: %i).\n", bcastSetupFilePath, accessError);
success = false;
break;
default:
qtss_printf("- PlaylistBroadcaster: Unable to access the broadcast description file.\n (path: %s, errno: %i).\n", bcastSetupFilePath, accessError);
success = false;
break;
}
}
return success;
}
static bool AddOurPIDToTracker( const char* bcastSetupFilePath )
{
// add our pid and Broadcast description file File to the tracker
#ifndef __Win32__
BCasterTracker tracker( sgTrackerFilePath );
if ( tracker.IsOpen() )
{ sgTrackingSucceeded = 1;
tracker.Add( getpid(), bcastSetupFilePath );
tracker.Save();
}
else
{
qtss_printf("- PlaylistBroadcaster: Could not open %s. Reason: access denied.\n", sgTrackerFilePath );
qtss_printf("- PlaylistBroadcaster: Change user or change the directory's privileges to access %s.\n",sgTrackerFilePath) ;
return false;
}
#endif
return true; // return true if pid was successfully added to the tracker
}
#if 0
static void ShowPickDistribution( PlaylistPicker *picker )
{
qtss_printf( "\n" );
qtss_printf( "Pick Distribution by Bucket\n" );
qtss_printf( "---------------------------\n" );
UInt32 bucketIndex;
for ( bucketIndex = 0; bucketIndex < picker->GetNumBuckets(); bucketIndex++ )
{
qtss_printf( "bucket total for w: %li, (%li)\n", (bucketIndex + 1), (SInt32)picker->mPickCounts[bucketIndex] );
}
}
// archaic debug code
static void PrintContents( PLDoubleLinkedListNode<SimplePlayListElement> *node, void * );
static void ShowPicker(PlaylistPicker *picker);
static void PrintContents( PLDoubleLinkedListNode<SimplePlayListElement> *node, void * )
{
qtss_printf( "element name %s\n", node->mElement->mElementName );
}
static void ShowPicker(PlaylistPicker *picker)
{
int x;
for ( x= 0; x < picker->GetNumBuckets(); x++ )
{
picker->GetBucket(x)->ForEach( PrintContents, NULL );
}
}
#endif
/* changed by emil@popwire.com (see relaod.txt for info) */
bool FileCreateAndCheckAccess(char *theFileName){
FILE *theFile;
#ifndef __Win32__
if(access(theFileName, F_OK)){
/* file does not exist - create and set rights */
theFile = ::fopen(theFileName, "w+");
if(theFile){
/* make sure everybody has r/w access to file */
(void)::chmod(theFileName, S_IRUSR|S_IWUSR|S_IRGRP|S_IWGRP|S_IROTH);
(void)::fclose(theFile);
}else return 1;
}else{
/* file exists - check rights */
if(access(theFileName, R_OK|W_OK))return 2;
}
#else
theFile = ::fopen(theFileName,"a");
if (theFile) ::fclose(theFile);
#endif
return 0;
}
static void PrintPlaylistElement(PLDoubleLinkedListNode<SimplePlayListElement> *node,void *file)
{
sElementCount ++;
if (sElementCount <= sMaxUpcomingListSize)
{ char* thePick = node->fElement->mElementName;
if (sSetupDirPath.EqualIgnoreCase(thePick, sSetupDirPath.Len) || '\\' == thePick[0] || '/' == thePick[0])
qtss_fprintf((FILE*)file,"%s\n", thePick);
else
qtss_fprintf((FILE*)file,"%s%s\n", sSetupDirPath.Ptr,thePick);
}
}
static void ShowPlaylistElements(PlaylistPicker *picker,FILE *file)
{
if (sElementCount > sMaxUpcomingListSize)
return;
UInt32 x;
for (x= 0;x<picker->GetNumBuckets();x++)
{
picker->GetBucket(x)->ForEach(PrintPlaylistElement,file);
}
}
/* ***************************************************** */
static void RegisterEventHandlers()
{
#ifdef __Win32__
SetConsoleCtrlHandler( (PHANDLER_ROUTINE) SignalEventHandler, true);
return;
#endif
#ifndef __Win32__
struct sigaction act;
#if defined(sun) || defined(i386) || defined(__MacOSX__) || defined(__powerpc__) || defined (__sgi_cc__) || defined(__osf__) || defined(__hpux__) || defined(__linux__)
sigemptyset(&act.sa_mask);
act.sa_flags = 0;
act.sa_handler = (void(*)(int))&SignalEventHandler;
#elif defined(__sgi__)
sigemptyset(&act.sa_mask);
act.sa_flags = 0;
act.sa_handler = (void(*)(...))&SignalEventHandler;
#else
act.sa_mask = 0;
act.sa_flags = 0;
act.sa_handler = (void(*)(...))&SignalEventHandler;
#endif
if ( ::signal(SIGTERM, SIG_IGN) != SIG_IGN)
{ // from kill...
if ( ::sigaction(SIGTERM, &act, NULL) != 0 )
{ qtss_printf( "- PlaylistBroadcaster: System error (%"_SPOINTERSIZEARG_").\n", (PointerSizedInt)SIG_ERR );
}
}
if ( ::signal(SIGINT, SIG_IGN) != SIG_IGN)
{ // ^C signal
if ( ::sigaction(SIGINT, &act, NULL) != 0 )
{ qtss_printf( "- PlaylistBroadcaster: System error (%"_SPOINTERSIZEARG_").\n", (PointerSizedInt)SIG_ERR );
}
}
if ( ::signal(SIGPIPE, SIG_IGN) != SIG_IGN)
{ // broken pipe probably from a failed RTSP session (the server went down?)
if ( ::sigaction(SIGPIPE, &act, NULL) != 0 )
{ qtss_printf( "- PlaylistBroadcaster: System error (%"_SPOINTERSIZEARG_").\n", (PointerSizedInt)SIG_ERR );
}
}
if ( ::signal(SIGHUP, SIG_IGN) != SIG_IGN)
{ // broken pipe probably from a failed RTSP session (the server went down?)
if ( ::sigaction(SIGHUP, &act, NULL) != 0)
{ qtss_printf( "- PlaylistBroadcaster: System error (%"_SPOINTERSIZEARG_").\n", (PointerSizedInt)SIG_ERR );
}
}
#endif
}
/* ========================================================================
* Signal and error handler.
*/
static void RemoveFiles(PLBroadcastDef* broadcastParms)
{
if (broadcastParms != NULL)
{
if (broadcastParms->mPIDFile != NULL)
remove(broadcastParms->mPIDFile);
if (broadcastParms->mStopFile != NULL)
remove(broadcastParms->mStopFile);
if (broadcastParms->mReplaceFile != NULL)
remove(broadcastParms->mReplaceFile);
if (broadcastParms->mInsertFile != NULL)
remove(broadcastParms->mInsertFile);
if (broadcastParms->mCurrentFile != NULL)
remove(broadcastParms->mCurrentFile);
if (broadcastParms->mUpcomingFile != NULL)
remove(broadcastParms->mUpcomingFile);
}
}
/* ========================================================================
* Signal and error handler.
*/
static void SignalEventHandler( int signalID )
{
#ifdef __Win32__
if ( (signalID != SIGINT) && (signalID != SIGTERM) )
#else
if (signalID == SIGPIPE)
#endif
sNumErrors++;
// evaluate the error
if (sRTSPClientError != 0 && !sErrorEvaluted)
{
EvalBroadcasterErr(sRTSPClientError);
sErrorEvaluted = true;
}
else if (sBroadcasterSession != NULL && !sErrorEvaluted)
{
#ifndef __Win32__
if ( (signalID == SIGINT) || (signalID == SIGTERM) )
{ EvalBroadcasterErr(QTFileBroadcaster::eNetworkConnectionStopped);
}
else
{ EvalBroadcasterErr(QTFileBroadcaster::eNetworkConnectionFailed);
}
#else
EvalBroadcasterErr(QTFileBroadcaster::eNetworkConnectionStopped);
#endif
sErrorEvaluted = true;
}
// do the cleanup - write warning and error messages and remove files
Cleanup();
#ifndef __Win32__
if (sBroadcasterSession != NULL)
{
if ( (signalID == SIGINT) || (signalID == SIGTERM) )
sQuitImmediate = true; // just in case we get called again
return; //we need to let the broadcaster session teardown and clean up
}
if ( sgTrackingSucceeded )
{
// give tracker scope so that it really does it's
// thing before "exit" is called.
BCasterTracker tracker( sgTrackerFilePath );
tracker.RemoveByProcessID( getpid() );
tracker.Save();
}
#endif
if (!sQuitImmediate) // do once
{
sQuitImmediate = true; // just in case we get called again
#ifdef __Win32__
if (sBroadcasterSession && !sBroadcasterSession->IsDone())
{ sBroadcasterSession->TearDownNow();
OSThread::Sleep(1000);
}
if (NULL == sBroadcasterSession)
qtss_printf("\n"); // make sure the message was printed before quitting.
#endif
return;
}
::exit(-1);
}
Reference in a new issue Copy permalink