自学教程：C++ strDup函数代码示例

MPEG2TransportStreamIndexFile::MPEG2TransportStreamIndexFile(UsageEnvironment& env, char const* indexFileName)  : Medium(env),    fFileName(strDup(indexFileName)), fFid(NULL), fMPEGVersion(0), fCurrentIndexRecordNum(0),    fCachedPCR(0.0f), fCachedTSPacketNumber(0), fNumIndexRecords(0) {  // Get the file size, to determine how many index records it contains:  u_int64_t indexFileSize = GetFileSize(indexFileName, NULL);  if (indexFileSize % INDEX_RECORD_SIZE != 0) {    env << "Warning: Size of the index file /"" << indexFileName 	<< "/" (" << (unsigned)indexFileSize	<< ") is not a multiple of the index record size ("	<< INDEX_RECORD_SIZE << ")/n";  }  fNumIndexRecords = (unsigned long)(indexFileSize/INDEX_RECORD_SIZE);}

ProxyRTSPClient::ProxyRTSPClient(ProxyServerMediaSession& ourServerMediaSession, char const* rtspURL,				 char const* username, char const* password,				 portNumBits tunnelOverHTTPPortNum, int verbosityLevel, int socketNumToServer)  : RTSPClient(ourServerMediaSession.envir(), rtspURL, verbosityLevel, "ProxyRTSPClient",	       tunnelOverHTTPPortNum == (portNumBits)(~0) ? 0 : tunnelOverHTTPPortNum, socketNumToServer),    fOurServerMediaSession(ourServerMediaSession), fOurURL(strDup(rtspURL)), fStreamRTPOverTCP(tunnelOverHTTPPortNum != 0),    fSetupQueueHead(NULL), fSetupQueueTail(NULL), fNumSetupsDone(0), fNextDESCRIBEDelay(1),    fServerSupportsGetParameter(False), fLastCommandWasPLAY(False), fResetOnNextLivenessTest(False),    fLivenessCommandTask(NULL), fDESCRIBECommandTask(NULL), fSubsessionTimerTask(NULL) {   if (username != NULL && password != NULL) {    fOurAuthenticator = new Authenticator(username, password);  } else {    fOurAuthenticator = NULL;  }}

void SIPClient::reset() {  fWorkingAuthenticator = NULL;  delete[] fInviteCmd; fInviteCmd = NULL; fInviteCmdSize = 0;  delete[] fInviteSDPDescription; fInviteSDPDescription = NULL;  delete[] (char*)fUserName; fUserName = strDup(fApplicationName);  fUserNameSize = strlen(fUserName);  fValidAuthenticator.reset();  delete[] (char*)fToTagStr; fToTagStr = NULL; fToTagStrSize = 0;  fServerPortNum = 0;  fServerAddress.s_addr = 0;  delete[] (char*)fURL; fURL = NULL; fURLSize = 0;}

void OnDemandServerMediaSubsession::setSDPLinesFromRTPSink(RTPSink* rtpSink, FramedSource* inputSource, unsigned estBitrate) {  if (rtpSink == NULL) return;  char const* mediaType = rtpSink->sdpMediaType();  unsigned char rtpPayloadType = rtpSink->rtpPayloadType();  AddressString ipAddressStr(fServerAddressForSDP);  char* rtpmapLine = rtpSink->rtpmapLine();  char const* rtcpmuxLine = fMultiplexRTCPWithRTP ? "a=rtcp-mux/r/n" : "";  char const* rangeLine = rangeSDPLine();  char const* auxSDPLine = getAuxSDPLine(rtpSink, inputSource);  if (auxSDPLine == NULL) auxSDPLine = "";  char const* const sdpFmt =    "m=%s %u RTP/AVP %d/r/n"    "c=IN IP4 %s/r/n"    "b=AS:%u/r/n"    "%s"    "%s"    "%s"    "%s"    "a=control:%s/r/n";  unsigned sdpFmtSize = strlen(sdpFmt)    + strlen(mediaType) + 5 /* max short len */ + 3 /* max char len */    + strlen(ipAddressStr.val())    + 20 /* max int len */    + strlen(rtpmapLine)    + strlen(rtcpmuxLine)    + strlen(rangeLine)    + strlen(auxSDPLine)    + strlen(trackId());  char* sdpLines = new char[sdpFmtSize];  sprintf(sdpLines, sdpFmt,	  mediaType, // m= <media>	  fPortNumForSDP, // m= <port>	  rtpPayloadType, // m= <fmt list>	  ipAddressStr.val(), // c= address	  estBitrate, // b=AS:<bandwidth>	  rtpmapLine, // a=rtpmap:... (if present)	  rtcpmuxLine, // a=rtcp-mux:... (if present)	  rangeLine, // a=range:... (if present)	  auxSDPLine, // optional extra SDP line	  trackId()); // a=control:<track-id>  delete[] (char*)rangeLine; delete[] rtpmapLine;  fSDPLines = strDup(sdpLines);  delete[] sdpLines;}

SimpleRTPSink::SimpleRTPSink(UsageEnvironment& env, Groupsock* RTPgs,			     unsigned char rtpPayloadFormat,			     unsigned rtpTimestampFrequency,			     char const* sdpMediaTypeString,			     char const* rtpPayloadFormatName,			     unsigned numChannels,			     Boolean allowMultipleFramesPerPacket,			     Boolean doNormalMBitRule)  : MultiFramedRTPSink(env, RTPgs, rtpPayloadFormat,		       rtpTimestampFrequency, rtpPayloadFormatName,		       numChannels),    fAllowMultipleFramesPerPacket(allowMultipleFramesPerPacket) {  fSDPMediaTypeString    = strDup(sdpMediaTypeString == NULL ? "unknown" : sdpMediaTypeString);  fSetMBitOnLastFrames = doNormalMBitRule && strcmp(fSDPMediaTypeString, "audio") != 0;}

/**Singleton constructor*/H264VideoSink::H264VideoSink(UsageEnvironment& env, MediaSubsession& subsession, char const* streamId):	MyVideoSink(env), m_fSubsession(subsession){	TRACE_INFO("Video sink constructor");	m_fStreamId = strDup(streamId);	//m_bufferSize=253440;//2*DUMMY_SINK_RECEIVE_BUFFER_SIZE;    //m_fPos = 0;    uint8_t startCode[] = {0x00, 0x00,0x01};	//m_buffer = new unsigned char[m_bufferSize];	//m_frameQueue=new CMediaQueue(200);	m_decoder=new CVideoDecoder("H264");	AddData(startCode, sizeof(startCode));	//InitializeCriticalSection(&m_criticalSection);	//m_ready=1;}

AudioPortNames* AudioInputDevice::getPortNames() {  WindowsAudioInputDevice::initializeIfNecessary();  AudioPortNames* portNames = new AudioPortNames;  portNames->numPorts = WindowsAudioInputDevice::numInputPortsTotal;  portNames->portName = new char*[WindowsAudioInputDevice::numInputPortsTotal];  // If there's more than one mixer, print only the port name.  // If there's two or more mixers, also include the mixer name  // (to disambiguate port names that may be the same name in different mixers)  char portNameBuffer[2*MAXPNAMELEN+10/*slop*/];  char mixerNameBuffer[MAXPNAMELEN];  char const* portNameFmt;  if (WindowsAudioInputDevice::numMixers <= 1) {    portNameFmt = "%s";  } else {    portNameFmt = "%s (%s)";  }  unsigned curPortNum = 0;  for (unsigned i = 0; i < WindowsAudioInputDevice::numMixers; ++i) {    Mixer& mixer = WindowsAudioInputDevice::ourMixers[i];    if (WindowsAudioInputDevice::numMixers <= 1) {      mixerNameBuffer[0] = '/0';    } else {      strncpy(mixerNameBuffer, mixer.name, sizeof mixerNameBuffer);#if 0      // Hack: Simplify the mixer name, by truncating after the first space character:      for (int k = 0; k < sizeof mixerNameBuffer && mixerNameBuffer[k] != '/0'; ++k) {	if (mixerNameBuffer[k] == ' ') {	  mixerNameBuffer[k] = '/0';	  break;	}      }#endif    }    for (unsigned j = 0; j < mixer.numPorts; ++j) {      sprintf(portNameBuffer, portNameFmt, mixer.ports[j].name, mixerNameBuffer);      portNames->portName[curPortNum++] = strDup(portNameBuffer);    }  }  return portNames;}

Boolean RTSPServerWithREGISTERProxying::weImplementREGISTER(char const* cmd/*"REGISTER" or "DEREGISTER"*/,		      char const* proxyURLSuffix, char*& responseStr) {  // First, check whether we have already proxied a stream as "proxyURLSuffix":  if (proxyURLSuffix != NULL) {    ServerMediaSession* sms = lookupServerMediaSession(proxyURLSuffix);    if ((strcmp(cmd, "REGISTER") == 0 && sms != NULL) ||	(strcmp(cmd, "DEREGISTER") == 0 && sms == NULL)) {      responseStr = strDup("451 Invalid parameter");      return False;    }  }  // Otherwise, we will implement it:  responseStr = NULL;  return True;}

Boolean MediaSession::parseSDPAttribute_type(char const* sdpLine) {  // Check for a "a=type:broadcast|meeting|moderated|test|H.332|recvonly" line:  Boolean parseSuccess = False;  char *resultStr = NULL;  char* buffer = strDupSize(sdpLine);  if (sscanf(sdpLine, "a=type: %[^ ]", buffer) == 1) {    resultStr = strDup(buffer);    if (resultStr != NULL) {      delete[] fMediaSessionType;      fMediaSessionType = resultStr;    }    parseSuccess = True;  }  delete[] buffer;  return parseSuccess;}

Boolean Groupsock::output(UsageEnvironment& env, unsigned char* buffer, unsigned bufferSize,			  DirectedNetInterface* interfaceNotToFwdBackTo) {  do {    // First, do the datagram send, to each destination:    Boolean writeSuccess = True;    for (destRecord* dests = fDests; dests != NULL; dests = dests->fNext) {      if (!write(dests->fGroupEId.groupAddress().s_addr, dests->fGroupEId.portNum(), dests->fGroupEId.ttl(),		 buffer, bufferSize)) {	writeSuccess = False;	break;      }    }    if (!writeSuccess) break;    statsOutgoing.countPacket(bufferSize);    statsGroupOutgoing.countPacket(bufferSize);    // Then, forward to our members:    int numMembers = 0;    if (!members().IsEmpty()) {      numMembers =	outputToAllMembersExcept(interfaceNotToFwdBackTo,				 ttl(), buffer, bufferSize,				 ourIPAddress(env));      if (numMembers < 0) break;    }    if (DebugLevel >= 3) {      env << *this << ": wrote " << bufferSize << " bytes, ttl " << (unsigned)ttl();      if (numMembers > 0) {	env << "; relayed to " << numMembers << " members";      }      env << "/n";    }    return True;  } while (0);  if (DebugLevel >= 0) { // this is a fatal error    UsageEnvironment::MsgString msg = strDup(env.getResultMsg());    env.setResultMsg("Groupsock write failed: ", msg);    delete[] (char*)msg;  }  return False;}

void QueueServerMediaSubsession::checkForAuxSDPLine1(){    char const* dasl;    if (fAuxSDPLine != NULL) {        // Signal the event loop that we're done:        setDoneFlag();    } else if (fDummyRTPSink != NULL && (dasl = fDummyRTPSink->auxSDPLine()) != NULL) {        fAuxSDPLine = strDup(dasl);        fDummyRTPSink = NULL;        // Signal the event loop that we're done:        setDoneFlag();    } else {        // try again after a brief delay:        int uSecsToDelay = 100000; // 100 ms        nextTask() = envir().taskScheduler().scheduleDelayedTask(                    uSecsToDelay,(TaskFunc*)checkForAuxSDPLine, this);    }}

OggFile::OggFile(UsageEnvironment& env, char const* fileName,                 onCreationFunc* onCreation, void* onCreationClientData)    : Medium(env),      fFileName(strDup(fileName)),      fOnCreation(onCreation), fOnCreationClientData(onCreationClientData) {    fTrackTable = new OggTrackTable;    fDemuxesTable = HashTable::create(ONE_WORD_HASH_KEYS);    FramedSource* inputSource = ByteStreamFileSource::createNew(envir(), fileName);    if (inputSource == NULL) {        // The specified input file does not exist!        fParserForInitialization = NULL;        handleEndOfBosPageParsing(); // we have no file, and thus no tracks, but we still need to signal this    } else {        // Initialize ourselves by parsing the file's headers:        fParserForInitialization            = new OggFileParser(*this, inputSource, handleEndOfBosPageParsing, this);    }}

char const*H264MediaSubsession::sdpLines() {  if (fSDPLines == NULL) {	AddressString ipAddressStr(fServerAddressForSDP);	const char* rtpmapLine = "a=rtpmap:96 H264/90000/r/n";	char const* rangeLine = rangeSDPLine();	char const* const sdpFmt =	"m=%s %u RTP/AVP %d/r/n"	"c=IN IP4 %s/r/n"	"b=AS:%u/r/n"	"%s"	"%s"	"%s"	"a=control:%s/r/n";	unsigned sdpFmtSize = strlen(sdpFmt)	+ strlen(mediaType) + 5 /* max short len */ + 3 /* max char len */	+ strlen(ipAddressStr.val())	+ 20 /* max int len */	+ strlen(rtpmapLine)	+ strlen(rangeLine)	+ strlen(auxSDPLine())	+ strlen(trackId());	char* sdpLines = new char[sdpFmtSize];	sprintf(sdpLines, sdpFmt,		mediaType, // m= <media>		fPortNumForSDP, // m= <port>		rtpPayloadType, // m= <fmt list>		ipAddressStr.val(), // c= address		m_Watcher->GetVideoBitrate(), // b=AS:<bandwidth>		rtpmapLine, // a=rtpmap:... (if present)		rangeLine, // a=range:... (if present)		auxSDPLine(), // optional extra SDP line		trackId()); // a=control:<track-id>		delete[] (char*)rangeLine; 		fSDPLines = strDup(sdpLines);	delete[] sdpLines;  }  return fSDPLines;}

char* SIPClient::invite(char const* url, Authenticator* authenticator) {  // First, check whether "url" contains a username:password to be used:  char* username; char* password;  if (authenticator == NULL      && parseSIPURLUsernamePassword(url, username, password)) {    char* result = inviteWithPassword(url, username, password);    delete[] username; delete[] password; // they were dynamically allocated    return result;  }  if (!processURL(url)) return NULL;  delete[] (char*)fURL; fURL = strDup(url);  fURLSize = strlen(fURL);  fCallId = our_random32();  fFromTag = our_random32();  return invite1(authenticator);}

node* process(node* root, char *word ){	int c;	if(root==NULL)	{		root=(node*)malloc(sizeof(node));		root->str=strDup(root->str,word);		root->count=1;		root->left=NULL;		root->right=NULL;	}	else if((c=strcmp(root->str,word)) < 0)		root->right=process(root->right,word);	else if(c > 0)		root->left=process(root->left,word);	else		root->count++;				return root;}

void BasicHashTable::assignKey(TableEntry *entry, char const *key){    // The way we assign the key depends upon its type:    if (fKeyType == STRING_HASH_KEYS)    {        entry->key = strDup(key);    }    else if (fKeyType == ONE_WORD_HASH_KEYS)    {        entry->key = key;    }    else if (fKeyType > 0)    {        unsigned *keyFrom = (unsigned *)key;        unsigned *keyTo = new unsigned[fKeyType];        for (int i = 0; i < fKeyType; ++i) keyTo[i] = keyFrom[i];        entry->key = (char const *)keyTo;    }}

Locale::Locale(char const* newLocale, LocaleCategory category) {#ifndef LOCALE_NOT_USED#ifndef XLOCALE_NOT_USED  int categoryMask;  switch (category) {    case All: { categoryMask = LC_ALL_MASK; break; }    case Numeric: { categoryMask = LC_NUMERIC_MASK; break; }  }  fLocale = newlocale(categoryMask, newLocale, NULL);  fPrevLocale = uselocale(fLocale);#else  switch (category) {    case All: { fCategoryNum = LC_ALL; break; }    case Numeric: { fCategoryNum = LC_NUMERIC; break; }  }  fPrevLocale = strDup(setlocale(fCategoryNum, NULL));  setlocale(fCategoryNum, newLocale);#endif#endif}

MediaSession::MediaSession(UsageEnvironment& env)  : Medium(env),    fSubsessionsHead(NULL), fSubsessionsTail(NULL),    fConnectionEndpointName(NULL), fMaxPlayStartTime(0.0f), fMaxPlayEndTime(0.0f),    fScale(1.0f), fMediaSessionType(NULL), fSessionName(NULL), fSessionDescription(NULL),    fControlPath(NULL) {  fSourceFilterAddr.s_addr = 0;  // Get our host name, and use this for the RTCP CNAME:  const unsigned maxCNAMElen = 100;  char CNAME[maxCNAMElen+1];#ifndef CRIS  gethostname((char*)CNAME, maxCNAMElen);#else  // "gethostname()" isn't defined for this platform  sprintf(CNAME, "unknown host %d", (unsigned)(our_random()*0x7FFFFFFF));#endif  CNAME[maxCNAMElen] = '/0'; // just in case  fCNAME = strDup(CNAME);}

Boolean RTSPRegisterSender::setRequestFields(RequestRecord* request,					     char*& cmdURL, Boolean& cmdURLWasAllocated,					     char const*& protocolStr,					     char*& extraHeaders, Boolean& extraHeadersWereAllocated) {  if (strcmp(request->commandName(), "REGISTER") == 0) {    RequestRecord_REGISTER* request_REGISTER = (RequestRecord_REGISTER*) request;    setBaseURL(request_REGISTER->rtspURLToRegister());    cmdURL = (char*)url();    cmdURLWasAllocated = False;    // Generate the "Transport:" header that will contain our REGISTER-specific parameters.  This will be "extraHeaders".    // First, generate the "proxy_url_suffix" parameter string, if any:    char* proxyURLSuffixParameterStr;    if (request_REGISTER->proxyURLSuffix() == NULL) {      proxyURLSuffixParameterStr = strDup("");    } else {      char const* proxyURLSuffixParameterFmt = "; proxy_url_suffix=%s";      unsigned proxyURLSuffixParameterSize = strlen(proxyURLSuffixParameterFmt)	+ strlen(request_REGISTER->proxyURLSuffix());      proxyURLSuffixParameterStr = new char[proxyURLSuffixParameterSize];      sprintf(proxyURLSuffixParameterStr, proxyURLSuffixParameterFmt, request_REGISTER->proxyURLSuffix());    }    char const* transportHeaderFmt = "Transport: %spreferred_delivery_protocol=%s%s/r/n";    unsigned transportHeaderSize = strlen(transportHeaderFmt) + 100/*conservative*/ + strlen(proxyURLSuffixParameterStr);    char* transportHeaderStr = new char[transportHeaderSize];    sprintf(transportHeaderStr, transportHeaderFmt,	    request_REGISTER->reuseConnection() ? "reuse_connection; " : "",	    request_REGISTER->requestStreamingViaTCP() ? "interleaved" : "udp",	    proxyURLSuffixParameterStr);    delete[] proxyURLSuffixParameterStr;    extraHeaders = transportHeaderStr;    extraHeadersWereAllocated = True;    return True;  } else {    return RTSPClient::setRequestFields(request, cmdURL, cmdURLWasAllocated, protocolStr, extraHeaders, extraHeadersWereAllocated);  }}

char const* MPEG4ESVideoRTPSink::auxSDPLine() {  // Generate a new "a=fmtp:" line each time, using our own 'configuration' information (if we have it),  // otherwise parameters from our framer source (in case they've changed since the last time that  // we were called):  unsigned configLength = fNumConfigBytes;  unsigned char* config = fConfigBytes;  if (fProfileAndLevelIndication == 0 || config == NULL) {    // We need to get this information from our framer source:    MPEG4VideoStreamFramer* framerSource = (MPEG4VideoStreamFramer*)fSource;    if (framerSource == NULL) return NULL; // we don't yet have a source    fProfileAndLevelIndication = framerSource->profile_and_level_indication();    if (fProfileAndLevelIndication == 0) return NULL; // our source isn't ready    config = framerSource->getConfigBytes(configLength);    if (config == NULL) return NULL; // our source isn't ready  }  char const* fmtpFmt =    "a=fmtp:%d "    "profile-level-id=%d;"    "config=";  unsigned fmtpFmtSize = strlen(fmtpFmt)    + 3 /* max char len */    + 3 /* max char len */    + 2*configLength /* 2*, because each byte prints as 2 chars */    + 2 /* trailing /r/n */;  char* fmtp = new char[fmtpFmtSize];  sprintf(fmtp, fmtpFmt, rtpPayloadType(), fProfileAndLevelIndication);  char* endPtr = &fmtp[strlen(fmtp)];  for (unsigned i = 0; i < configLength; ++i) {    sprintf(endPtr, "%02X", config[i]);    endPtr += 2;  }  sprintf(endPtr, "/r/n");  delete[] fFmtpSDPLine;  fFmtpSDPLine = strDup(fmtp);  delete[] fmtp;  return fFmtpSDPLine;}

RTPSink::RTPSink(UsageEnvironment& env,		 Groupsock* rtpGS, unsigned char rtpPayloadType,		 unsigned rtpTimestampFrequency,		 char const* rtpPayloadFormatName,		 unsigned numChannels)  : MediaSink(env), fRTPInterface(this, rtpGS),    fRTPPayloadType(rtpPayloadType),    fPacketCount(0), fOctetCount(0), fTotalOctetCount(0),    fTimestampFrequency(rtpTimestampFrequency), fNextTimestampHasBeenPreset(True),    fNumChannels(numChannels) {  fRTPPayloadFormatName    = strDup(rtpPayloadFormatName == NULL ? "???" : rtpPayloadFormatName);  gettimeofday(&fCreationTime, NULL);  fTotalOctetCountStartTime = fCreationTime;  fSeqNo = (u_int16_t)our_random();  fSSRC = our_random32();  fTimestampBase = our_random32();  fTransmissionStatsDB = new RTPTransmissionStatsDB(*this);}

// A special version of "parseTransportHeader()", used just for parsing the "Transport:" header in an incoming "REGISTER" command:void parseTransportHeaderForREGISTER(char const* buf,				     Boolean &reuseConnection,				     Boolean& deliverViaTCP,				     char*& proxyURLSuffix) {  // Initialize the result parameters to default values:  reuseConnection = False;  deliverViaTCP = False;  proxyURLSuffix = NULL;    // First, find "Transport:"  while (1) {    if (*buf == '/0') return; // not found    if (*buf == '/r' && *(buf+1) == '/n' && *(buf+2) == '/r') return; // end of the headers => not found    if (_strncasecmp(buf, "Transport:", 10) == 0) break;    ++buf;  }    // Then, run through each of the fields, looking for ones we handle:  char const* fields = buf + 10;  while (*fields == ' ') ++fields;  char* field = strDupSize(fields);  while (sscanf(fields, "%[^;/r/n]", field) == 1) {    if (strcmp(field, "reuse_connection") == 0) {      reuseConnection = True;    } else if (_strncasecmp(field, "preferred_delivery_protocol=udp", 31) == 0) {      deliverViaTCP = False;    } else if (_strncasecmp(field, "preferred_delivery_protocol=interleaved", 39) == 0) {      deliverViaTCP = True;    } else if (_strncasecmp(field, "proxy_url_suffix=", 17) == 0) {      delete[] proxyURLSuffix;      proxyURLSuffix = strDup(field+17);    }        fields += strlen(field);    while (*fields == ';' || *fields == ' ' || *fields == '/t') ++fields; // skip over separating ';' chars or whitespace    if (*fields == '/0' || *fields == '/r' || *fields == '/n') break;  }  delete[] field;}

Boolean RTSPDeregisterSender::setRequestFields(RequestRecord* request,					       char*& cmdURL, Boolean& cmdURLWasAllocated,					       char const*& protocolStr,					       char*& extraHeaders, Boolean& extraHeadersWereAllocated) {  if (strcmp(request->commandName(), "DEREGISTER") == 0) {    RequestRecord_DEREGISTER* request_DEREGISTER = (RequestRecord_DEREGISTER*)request;    setBaseURL(request_DEREGISTER->rtspURLToDeregister());    cmdURL = (char*)url();    cmdURLWasAllocated = False;    // Generate the "Transport:" header that will contain our DEREGISTER-specific parameters.  This will be "extraHeaders".    // First, generate the "proxy_url_suffix" parameter string, if any:    char* proxyURLSuffixParameterStr;    if (request_DEREGISTER->proxyURLSuffix() == NULL) {      proxyURLSuffixParameterStr = strDup("");    } else {      char const* proxyURLSuffixParameterFmt = "proxy_url_suffix=%s";      unsigned proxyURLSuffixParameterSize = strlen(proxyURLSuffixParameterFmt)	+ strlen(request_DEREGISTER->proxyURLSuffix());      proxyURLSuffixParameterStr = new char[proxyURLSuffixParameterSize];      sprintf(proxyURLSuffixParameterStr, proxyURLSuffixParameterFmt, request_DEREGISTER->proxyURLSuffix());    }    char const* transportHeaderFmt = "Transport: %s/r/n";    unsigned transportHeaderSize = strlen(transportHeaderFmt) + strlen(proxyURLSuffixParameterStr);    char* transportHeaderStr = new char[transportHeaderSize];    sprintf(transportHeaderStr, transportHeaderFmt,	    proxyURLSuffixParameterStr);    delete[] proxyURLSuffixParameterStr;    extraHeaders = transportHeaderStr;    extraHeadersWereAllocated = True;    return True;  } else {    return RTSPClient::setRequestFields(request, cmdURL, cmdURLWasAllocated, protocolStr, extraHeaders, extraHeadersWereAllocated);  }}

/*! Creates a new expression struct with the given type    @param type     the type of data to be stored in the expression    @return         the new expression struct*/inline expression* newExpressionOfType (datatype type) {	exprvals ev;	switch(type) {		case TYPE_NIL:			break;		case TYPE_EXP:			ev.expval = NULL;			break;		case TYPE_LAZ:			ev.lazval = newLazyExpression();			break;		case TYPE_INT:			ev.intval = 0;			break;		case TYPE_FLO:			ev.floval = 0;			break;		case TYPE_STR:			ev.strval = newString(strDup(""));			break;		case TYPE_ARR:			ev.arrval = newArray(0);			break;		case TYPE_DAT:			ev.datval = time(NULL);			break;		case TYPE_OBJ:			// TODO			break;		case TYPE_FUN:			ev.funval = newTapFunction(NULL, 0, 0, newExpressionNil());			break;		case TYPE_TYP:			ev.intval = TYPE_UNK;			break;	}    return newExpressionAll(type, &ev, NULL, 0); // set the value to null until a real value is given and set the next expression to null}

char const* MPEG4ESVideoRTPSink::auxSDPLine() {  // Generate a new "a=fmtp:" line each time, using parameters from  // our framer source (in case they've changed since the last time that  // we were called):  MPEG4VideoStreamFramer* framerSource = (MPEG4VideoStreamFramer*)fSource;  if (framerSource == NULL) return NULL; // we don't yet have a source  u_int8_t profile_level_id = framerSource->profile_and_level_indication();  if (profile_level_id == 0) return NULL; // our source isn't ready  unsigned configLength;  unsigned char* config = framerSource->getConfigBytes(configLength);  if (config == NULL) return NULL; // our source isn't ready  char const* fmtpFmt =    "a=fmtp:%d "    "profile-level-id=%d;"    "config=";  unsigned fmtpFmtSize = strlen(fmtpFmt)    + 3 /* max char len */    + 3 /* max char len */    + 2*configLength /* 2*, because each byte prints as 2 chars */    + 2 /* trailing /r/n */;  char* fmtp = new char[fmtpFmtSize];  sprintf(fmtp, fmtpFmt, rtpPayloadType(), profile_level_id);  char* endPtr = &fmtp[strlen(fmtp)];  for (unsigned i = 0; i < configLength; ++i) {    sprintf(endPtr, "%02X", config[i]);    endPtr += 2;  }  sprintf(endPtr, "/r/n");  delete[] fAuxSDPLine;  fAuxSDPLine = strDup(fmtp);  delete[] fmtp;  return fAuxSDPLine;}

H264VideoRTPSink::H264VideoRTPSink(UsageEnvironment& env, Groupsock* RTPgs,                   unsigned char rtpPayloadFormat,                   unsigned profile_level_id,                   char const* sprop_parameter_sets_str)    : VideoRTPSink(env, RTPgs, rtpPayloadFormat, 90000, "H264"),      fOurFragmenter(NULL) {    // Set up the "a=fmtp:" SDP line for this stream:    char const* fmtpFmt =        "a=fmtp:%d packetization-mode=1"        ";profile-level-id=%06X"        ";sprop-parameter-sets=%s/r/n";    unsigned fmtpFmtSize = strlen(fmtpFmt)                           + 3 /* max char len */                           + 8 /* max unsigned len in hex */                           + strlen(sprop_parameter_sets_str);    char* fmtp = new char[fmtpFmtSize];    sprintf(fmtp, fmtpFmt,            rtpPayloadFormat,            profile_level_id,            sprop_parameter_sets_str);    fFmtpSDPLine = strDup(fmtp);    delete[] fmtp;}

char* RTSPServer::rtspURLPrefix(int clientSocket) const {  struct sockaddr_in ourAddress;  if (clientSocket < 0) {		// Use our default IP address in the URL:	  ourAddress.sin_addr.s_addr = ReceivingInterfaceAddr != 0			? ReceivingInterfaceAddr			: ourIPAddress(envir()); // hack	} else {	  SOCKLEN_T namelen = sizeof ourAddress;	  getsockname(clientSocket, (struct sockaddr*)&ourAddress, &namelen);	}  char urlBuffer[100]; // more than big enough for "rtsp://<ip-address>:<port>/"  portNumBits portNumHostOrder = ntohs(fServerPort.num());  if (portNumHostOrder == 554 /* the default port number */) {	  sprintf(urlBuffer, "rtsp://%s/", our_inet_ntoa(ourAddress.sin_addr));	} else {	  sprintf(urlBuffer, "rtsp://%s:%hu/",		  our_inet_ntoa(ourAddress.sin_addr), portNumHostOrder);	}  return strDup(urlBuffer);}

Boolean MediaSubsession::parseSDPAttribute_rtpmap(char const* sdpLine) {  // Check for a "a=rtpmap:<fmt> <codec>/<freq>" line:  // (Also check without the "/<freq>"; RealNetworks omits this)  // Also check for a trailing "/<numChannels>".  Boolean parseSuccess = False;  // 获取编码类型和时钟频率.  unsigned rtpmapPayloadFormat;  char* codecName = strDupSize(sdpLine); // ensures we have enough space  unsigned rtpTimestampFrequency = 0;  unsigned numChannels = 1;  if (sscanf(sdpLine, "a=rtpmap: %u %[^/]/%u/%u",	     &rtpmapPayloadFormat, codecName, &rtpTimestampFrequency,	     &numChannels) == 4      || sscanf(sdpLine, "a=rtpmap: %u %[^/]/%u",	     &rtpmapPayloadFormat, codecName, &rtpTimestampFrequency) == 3      || sscanf(sdpLine, "a=rtpmap: %u %s",		&rtpmapPayloadFormat, codecName) == 2) {    parseSuccess = True;    if (rtpmapPayloadFormat == fRTPPayloadFormat) {      // This "rtpmap" matches our payload format, so set our      // codec name and timestamp frequency:      // (First, make sure the codec name is upper case)      {	Locale l("POSIX");	for (char* p = codecName; *p != '/0'; ++p) *p = toupper(*p);      }      delete[] fCodecName; fCodecName = strDup(codecName);      fRTPTimestampFrequency = rtpTimestampFrequency;      fNumChannels = numChannels;    }  }  delete[] codecName;  return parseSuccess;}

void getSDPDescription(RTSPClient::responseHandler* afterFunc) {  extern char* proxyServerName;  if (proxyServerName != NULL) {    // Tell the SIP client about the proxy:    NetAddressList addresses(proxyServerName);    if (addresses.numAddresses() == 0) {      ourSIPClient->envir() << "Failed to find network address for /"" << proxyServerName << "/"/n";    } else {      NetAddress address = *(addresses.firstAddress());      unsigned proxyServerAddress // later, allow for IPv6 #####	= *(unsigned*)(address.data());      extern unsigned short proxyServerPortNum;      if (proxyServerPortNum == 0) proxyServerPortNum = 5060; // default      ourSIPClient->setProxyServer(proxyServerAddress, proxyServerPortNum);    }  }  extern unsigned short desiredPortNum;  unsigned short clientStartPortNum = desiredPortNum;  if (clientStartPortNum == 0) clientStartPortNum = 8000; // default  ourSIPClient->setClientStartPortNum(clientStartPortNum);  extern char const* streamURL;  char const* username = ourAuthenticator == NULL ? NULL : ourAuthenticator->username();  char const* password = ourAuthenticator == NULL ? NULL : ourAuthenticator->password();  char* result;  if (username != NULL && password != NULL) {    result = ourSIPClient->inviteWithPassword(streamURL, username, password);  } else {    result = ourSIPClient->invite(streamURL);  }  int resultCode = result == NULL ? -1 : 0;  afterFunc(NULL, resultCode, strDup(result));}

char*SIPClient::createAuthenticatorString(Authenticator const* authenticator,				      char const* cmd, char const* url) {  if (authenticator != NULL && authenticator->realm() != NULL      && authenticator->nonce() != NULL && authenticator->username() != NULL      && authenticator->password() != NULL) {    // We've been provided a filled-in authenticator, so use it:    char const* const authFmt      = "Proxy-Authorization: Digest username=/"%s/", realm=/"%s/", nonce=/"%s/", response=/"%s/", uri=/"%s/"/r/n";    char const* response = authenticator->computeDigestResponse(cmd, url);    unsigned authBufSize = strlen(authFmt)      + strlen(authenticator->username()) + strlen(authenticator->realm())      + strlen(authenticator->nonce()) + strlen(url) + strlen(response);    char* authenticatorStr = new char[authBufSize];    sprintf(authenticatorStr, authFmt,	    authenticator->username(), authenticator->realm(),	    authenticator->nonce(), response, url);    authenticator->reclaimDigestResponse(response);    return authenticatorStr;  }  return strDup("");}