The Tor Browser / file revision

media/webrtc/signaling/src/softphonewrapper/CC_SIPCCCallInfo.cpp@ac0c01689b40

media/webrtc/signaling/src/softphonewrapper/CC_SIPCCCallInfo.cpp

Thu, 15 Jan 2015 15:59:08 +0100

author
Michael Schloh von Bennewitz <michael@schloh.com>
date
Thu, 15 Jan 2015 15:59:08 +0100
branch
TOR_BUG_9701
changeset 10
ac0c01689b40
permissions
-rw-r--r--

Implement a real Private Browsing Mode condition by changing the API/ABI;
This solves Tor bug #9701, complying with disk avoidance documented in
https://www.torproject.org/projects/torbrowser/design/#disk-avoidance.

     1 /* This Source Code Form is subject to the terms of the Mozilla Public

     2  * License, v. 2.0. If a copy of the MPL was not distributed with this

     3  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */

     4 

     5 #include "CSFLog.h"

     6 

     7 #include "CC_Common.h"

     8 

     9 #include "CC_SIPCCCallInfo.h"

    10 #include "CC_SIPCCLine.h"

    11 

    12 extern "C"

    13 {

    14 #include "ccapi_call.h"

    15 #include "ccapi_call_info.h"

    16 #include "fsmdef_states.h"

    17 }

    18 

    19 static const char* logTag = "CC_SIPCCCallInfo";

    20 

    21 using namespace std;

    22 using namespace CSF;

    23 

    24 CC_SIPCCCallInfo::CC_SIPCCCallInfo (cc_callinfo_ref_t callinfo) : callinfo_ref(callinfo)

    25 {

    26     CCAPI_Call_retainCallInfo(callinfo);

    27 }

    28 

    29 CSF_IMPLEMENT_WRAP(CC_SIPCCCallInfo, cc_callinfo_ref_t);

    30 

    31 CC_SIPCCCallInfo::~CC_SIPCCCallInfo()

    32 {

    33     CCAPI_Call_releaseCallInfo(callinfo_ref);

    34 }

    35 

    36 bool CC_SIPCCCallInfo::hasCapability (CC_CallCapabilityEnum::CC_CallCapability capability)

    37 {

    38 	generateCapabilities();

    39 	return (caps.find(capability) != caps.end());

    40 }

    41 

    42 set<CC_CallCapabilityEnum::CC_CallCapability> CC_SIPCCCallInfo::getCapabilitySet()

    43 {

    44 	generateCapabilities();

    45     set<CC_CallCapabilityEnum::CC_CallCapability> callCaps(caps);

    46     return callCaps;

    47 }

    48 

    49 /*

    50 CC_LinePtr CC_SIPCCCallInfo::getLine ()

    51 {

    52 }

    53 */

    54 

    55 cc_call_state_t CC_SIPCCCallInfo::getCallState()

    56 {

    57     return CCAPI_CallInfo_getCallState(callinfo_ref);

    58 }

    59 

    60 fsmdef_states_t CC_SIPCCCallInfo::getFsmState() const

    61 {

    62     return CCAPI_CallInfo_getFsmState(callinfo_ref);

    63 }

    64 

    65 std::string CC_SIPCCCallInfo::fsmStateToString (fsmdef_states_t state) const

    66 {

    67   return fsmdef_state_name(state);

    68 }

    69 

    70 std::string CC_SIPCCCallInfo::callStateToString (cc_call_state_t state)

    71 {

    72   std::string statestr = "";

    73 

    74     switch(state) {

    75       case OFFHOOK:

    76         statestr = "OFFHOOK";

    77         break;

    78       case ONHOOK:

    79         statestr = "ONHOOK";

    80         break;

    81       case RINGOUT:

    82         statestr = "RINGOUT";

    83         break;

    84       case RINGIN:

    85         statestr = "RINGIN";

    86         break;

    87       case PROCEED:

    88         statestr = "PROCEED";

    89         break;

    90       case CONNECTED:

    91         statestr = "CONNECTED";

    92         break;

    93       case HOLD:

    94         statestr = "ONHOOK";

    95         break;

    96       case REMHOLD:

    97         statestr = "REMHOLD";

    98         break;

    99       case RESUME:

   100         statestr = "RESUME";

   101         break;

   102       case BUSY:

   103         statestr = "BUSY";

   104         break;

   105       case REORDER:

   106         statestr = "REORDER";

   107         break;

   108       case CONFERENCE:

   109         statestr = "CONFERENCE";

   110         break;

   111       case DIALING:

   112         statestr = "DIALING";

   113         break;

   114       case REMINUSE:

   115         statestr = "REMINUSE";

   116         break;

   117       case HOLDREVERT:

   118         statestr = "HOLDREVERT";

   119         break;

   120       case WHISPER:

   121         statestr = "WHISPER";

   122         break;

   123       case PRESERVATION:

   124         statestr = "PRESERVATION";

   125         break;

   126       case WAITINGFORDIGITS:

   127         statestr = "WAITINGFORDIGITS";

   128         break;

   129       case CREATEOFFERSUCCESS:

   130         statestr = "CREATEOFFERSUCCESS";

   131         break;

   132       case CREATEANSWERSUCCESS:

   133         statestr = "CREATEANSWERSUCCESS";

   134         break;

   135       case CREATEOFFERERROR:

   136         statestr = "CREATEOFFERERROR";

   137         break;

   138       case CREATEANSWERERROR:

   139         statestr = "CREATEANSWERERROR";

   140         break;

   141       case SETLOCALDESCSUCCESS:

   142         statestr = "SETLOCALDESCSUCCESS";

   143         break;

   144       case SETREMOTEDESCSUCCESS:

   145         statestr = "SETREMOTEDESCSUCCESS";

   146         break;

   147       case UPDATELOCALDESC:

   148         statestr = "UPDATELOCALDESC";

   149         break;

   150       case SETLOCALDESCERROR:

   151         statestr = "SETLOCALDESCERROR";

   152         break;

   153       case SETREMOTEDESCERROR:

   154         statestr = "SETREMOTEDESCERROR";

   155         break;

   156       case REMOTESTREAMADD:

   157         statestr = "REMOTESTREAMADD";

   158         break;

   159       case ADDICECANDIDATE:

   160         statestr = "ADDICECANDIDATE";

   161         break;

   162       case ADDICECANDIDATEERROR:

   163         statestr = "ADDICECANDIDATEERROR";

   164         break;

   165       default:

   166         break;

   167     }

   168 

   169     return statestr;

   170 }

   171 

   172 std::string CC_SIPCCCallInfo::callEventToString (ccapi_call_event_e callEvent)

   173 {

   174   std::string statestr = "";

   175 

   176     switch(callEvent) {

   177       case CCAPI_CALL_EV_CREATED:

   178         statestr = "CCAPI_CALL_EV_CREATED";

   179         break;

   180       case CCAPI_CALL_EV_STATE:

   181         statestr = "CCAPI_CALL_EV_STATE";

   182         break;

   183       case CCAPI_CALL_EV_CALLINFO:

   184         statestr = "CCAPI_CALL_EV_CALLINFO";

   185         break;

   186       case CCAPI_CALL_EV_ATTR:

   187         statestr = "CCAPI_CALL_EV_ATTR";

   188         break;

   189       case CCAPI_CALL_EV_SECURITY:

   190         statestr = "CCAPI_CALL_EV_SECURITY";

   191         break;

   192       case CCAPI_CALL_EV_LOG_DISP:

   193         statestr = "CCAPI_CALL_EV_LOG_DISP";

   194         break;

   195       case CCAPI_CALL_EV_PLACED_CALLINFO:

   196         statestr = "CCAPI_CALL_EV_PLACED_CALLINFO";

   197         break;

   198       case CCAPI_CALL_EV_STATUS:

   199         statestr = "CCAPI_CALL_EV_STATUS";

   200         break;

   201       case CCAPI_CALL_EV_SELECT:

   202         statestr = "CCAPI_CALL_EV_SELECT";

   203         break;

   204       case CCAPI_CALL_EV_LAST_DIGIT_DELETED:

   205         statestr = "CCAPI_CALL_EV_LAST_DIGIT_DELETED";

   206         break;

   207       case CCAPI_CALL_EV_GCID:

   208         statestr = "CCAPI_CALL_EV_GCID";

   209         break;

   210       case CCAPI_CALL_EV_XFR_OR_CNF_CANCELLED:

   211         statestr = "CCAPI_CALL_EV_XFR_OR_CNF_CANCELLED";

   212         break;

   213       case CCAPI_CALL_EV_PRESERVATION:

   214         statestr = "CCAPI_CALL_EV_PRESERVATION";

   215         break;

   216       case CCAPI_CALL_EV_CAPABILITY:

   217         statestr = "CCAPI_CALL_EV_CAPABILITY";

   218         break;

   219       case CCAPI_CALL_EV_VIDEO_AVAIL:

   220         statestr = "CCAPI_CALL_EV_VIDEO_AVAIL";

   221         break;

   222       case CCAPI_CALL_EV_VIDEO_OFFERED:

   223         statestr = "CCAPI_CALL_EV_VIDEO_OFFERED";

   224         break;

   225       case CCAPI_CALL_EV_RECEIVED_INFO:

   226         statestr = "CCAPI_CALL_EV_RECEIVED_INFO";

   227         break;

   228       case CCAPI_CALL_EV_RINGER_STATE:

   229         statestr = "CCAPI_CALL_EV_RINGER_STATE";

   230         break;

   231       case CCAPI_CALL_EV_CONF_PARTICIPANT_INFO:

   232         statestr = "CCAPI_CALL_EV_CONF_PARTICIPANT_INFO";

   233         break;

   234       case CCAPI_CALL_EV_MEDIA_INTERFACE_UPDATE_BEGIN:

   235         statestr = "CCAPI_CALL_EV_MEDIA_INTERFACE_UPDATE_BEGIN";

   236         break;

   237       case CCAPI_CALL_EV_MEDIA_INTERFACE_UPDATE_SUCCESSFUL:

   238         statestr = "CCAPI_CALL_EV_MEDIA_INTERFACE_UPDATE_SUCCESSFUL";

   239         break;

   240       case CCAPI_CALL_EV_MEDIA_INTERFACE_UPDATE_FAIL:

   241         statestr = "CCAPI_CALL_EV_MEDIA_INTERFACE_UPDATE_FAIL";

   242         break;

   243       default:

   244         break;

   245     }

   246 

   247     return statestr;

   248 }

   249 

   250 bool CC_SIPCCCallInfo::getRingerState()

   251 {

   252     if (CCAPI_CallInfo_getRingerState(callinfo_ref))

   253     {

   254     	return true;

   255     }

   256     else

   257     {

   258     	return false;

   259     }

   260 }

   261 

   262 cc_call_attr_t CC_SIPCCCallInfo::getCallAttr()

   263 {

   264     return CCAPI_CallInfo_getCallAttr(callinfo_ref);

   265 }

   266 

   267 cc_call_type_t CC_SIPCCCallInfo::getCallType()

   268 {

   269     return CCAPI_CallInfo_getCallType(callinfo_ref);

   270 }

   271 

   272 string CC_SIPCCCallInfo::getCalledPartyName()

   273 {

   274     return CCAPI_CallInfo_getCalledPartyName(callinfo_ref);

   275 }

   276 

   277 string CC_SIPCCCallInfo::getCalledPartyNumber()

   278 {

   279     return CCAPI_CallInfo_getCalledPartyNumber(callinfo_ref);

   280 }

   281 

   282 string CC_SIPCCCallInfo::getCallingPartyName()

   283 {

   284     return CCAPI_CallInfo_getCallingPartyName(callinfo_ref);

   285 }

   286 

   287 string CC_SIPCCCallInfo::getCallingPartyNumber()

   288 {

   289     return CCAPI_CallInfo_getCallingPartyNumber(callinfo_ref);

   290 }

   291 

   292 string CC_SIPCCCallInfo::getAlternateNumber()

   293 {

   294     return CCAPI_CallInfo_getAlternateNumber(callinfo_ref);

   295 }

   296 

   297 CC_LinePtr CC_SIPCCCallInfo::getline ()

   298 {

   299     cc_lineid_t lineId = CCAPI_CallInfo_getLine(callinfo_ref);

   300     return CC_SIPCCLine::wrap(lineId).get();

   301 }

   302 

   303 string CC_SIPCCCallInfo::getOriginalCalledPartyName()

   304 {

   305     return CCAPI_CallInfo_getOriginalCalledPartyName(callinfo_ref);

   306 }

   307 

   308 string CC_SIPCCCallInfo::getOriginalCalledPartyNumber()

   309 {

   310     return CCAPI_CallInfo_getOriginalCalledPartyNumber(callinfo_ref);

   311 }

   312 

   313 string CC_SIPCCCallInfo::getLastRedirectingPartyName()

   314 {

   315     return CCAPI_CallInfo_getLastRedirectingPartyName(callinfo_ref);

   316 }

   317 

   318 string CC_SIPCCCallInfo::getLastRedirectingPartyNumber()

   319 {

   320     return CCAPI_CallInfo_getLastRedirectingPartyNumber(callinfo_ref);

   321 }

   322 

   323 string CC_SIPCCCallInfo::getPlacedCallPartyName()

   324 {

   325     return CCAPI_CallInfo_getPlacedCallPartyName(callinfo_ref);

   326 }

   327 

   328 string CC_SIPCCCallInfo::getPlacedCallPartyNumber()

   329 {

   330     return CCAPI_CallInfo_getPlacedCallPartyNumber(callinfo_ref);

   331 }

   332 

   333 cc_int32_t CC_SIPCCCallInfo::getCallInstance()

   334 {

   335     return CCAPI_CallInfo_getCallInstance(callinfo_ref);

   336 }

   337 

   338 string CC_SIPCCCallInfo::getStatus()

   339 {

   340     return CCAPI_CallInfo_getStatus(callinfo_ref);

   341 }

   342 

   343 cc_call_security_t CC_SIPCCCallInfo::getSecurity()

   344 {

   345     return CCAPI_CallInfo_getSecurity(callinfo_ref);

   346 }

   347 

   348 cc_int32_t CC_SIPCCCallInfo::getSelectionStatus()

   349 {

   350     return CCAPI_CallInfo_getSelectionStatus(callinfo_ref);

   351 }

   352 

   353 string CC_SIPCCCallInfo::getGCID()

   354 {

   355     return CCAPI_CallInfo_getGCID(callinfo_ref);

   356 }

   357 

   358 bool CC_SIPCCCallInfo::getIsRingOnce()

   359 {

   360     return (CCAPI_CallInfo_getIsRingOnce(callinfo_ref) != 0);

   361 }

   362 

   363 int CC_SIPCCCallInfo::getRingerMode()

   364 {

   365     return CCAPI_CallInfo_getRingerMode(callinfo_ref);

   366 }

   367 

   368 cc_int32_t CC_SIPCCCallInfo::getOnhookReason()

   369 {

   370     return CCAPI_CallInfo_getOnhookReason(callinfo_ref);

   371 }

   372 

   373 bool CC_SIPCCCallInfo::getIsConference()

   374 {

   375     return (CCAPI_CallInfo_getIsConference(callinfo_ref) != 0);

   376 }

   377 

   378 set<cc_int32_t> CC_SIPCCCallInfo::getStreamStatistics()

   379 {

   380     CSFLogError(logTag, "CCAPI_CallInfo_getCapabilitySet() NOT IMPLEMENTED IN PSIPCC.");

   381     set<cc_int32_t> stats;

   382     return stats;

   383 }

   384 

   385 bool CC_SIPCCCallInfo::isCallSelected()

   386 {

   387     return (CCAPI_CallInfo_isCallSelected(callinfo_ref) != 0);

   388 }

   389 

   390 string CC_SIPCCCallInfo::getINFOPack()

   391 {

   392     return CCAPI_CallInfo_getINFOPack(callinfo_ref);

   393 }

   394 

   395 string CC_SIPCCCallInfo::getINFOType()

   396 {

   397     return CCAPI_CallInfo_getINFOType(callinfo_ref);

   398 }

   399 

   400 string CC_SIPCCCallInfo::getINFOBody()

   401 {

   402     return CCAPI_CallInfo_getINFOBody(callinfo_ref);

   403 }

   404 

   405 cc_calllog_ref_t  CC_SIPCCCallInfo::getCallLogRef()

   406 {

   407     return CCAPI_CallInfo_getCallLogRef(callinfo_ref);

   408 }

   409 

   410 cc_sdp_direction_t CC_SIPCCCallInfo::getVideoDirection()

   411 {

   412     return CCAPI_CallInfo_getVideoDirection(callinfo_ref);

   413 }

   414 

   415 int CC_SIPCCCallInfo::getVolume()

   416 {

   417     if( pMediaData != nullptr)

   418     {

   419         return  pMediaData->volume;

   420     }

   421     else

   422     {

   423         return -1;

   424     }

   425 }

   426 

   427 bool CC_SIPCCCallInfo::isAudioMuted()

   428 {

   429     return (CCAPI_CallInfo_isAudioMuted(callinfo_ref) != 0);

   430 }

   431 

   432 bool CC_SIPCCCallInfo::isVideoMuted()

   433 {

   434     return (CCAPI_CallInfo_isVideoMuted(callinfo_ref) != 0);

   435 }

   436 

   437 string CC_SIPCCCallInfo::getSDP()

   438 {

   439     return CCAPI_CallInfo_getSDP(callinfo_ref);

   440 }

   441 

   442 cc_int32_t CC_SIPCCCallInfo::getStatusCode()

   443 {

   444     return CCAPI_CallInfo_getStatusCode(callinfo_ref);

   445 }

   446 

   447 MediaStreamTable* CC_SIPCCCallInfo::getMediaStreams() const

   448 {

   449 	return CCAPI_CallInfo_getMediaStreams(callinfo_ref);

   450 }

   451 

   452 Timecard *CC_SIPCCCallInfo::takeTimecard()

   453 {

   454     return CCAPI_CallInfo_takeTimecard(callinfo_ref);

   455 }

   456 

   457 std::string CC_SIPCCCallInfo::getCandidate()

   458 {

   459     return CCAPI_CallInfo_getCandidate(callinfo_ref);

   460 }

   461 

   462 bool CC_SIPCCCallInfo::isMediaStateAvailable()

   463 {

   464     // for softphone it will always be possible to query the mute state and video direction

   465     return true;

   466 }

   467 

   468 

   469 #define PRINT_IF_CC_CAP_TRUE(cap) ((hasFeature(cap)) ? string(#cap) + ",": "")

   470 void CC_SIPCCCallInfo::generateCapabilities()

   471 {

   472 	// If caps are already generated, no need to repeat the exercise.

   473 	if(!caps.empty())

   474 		return;

   475 /*

   476 	CSFLogDebugS( logTag, "generateCapabilities() state=" << getCallState() <<

   477 			" underlyingCaps=" <<

   478 			PRINT_IF_CC_CAP_TRUE(CCAPI_CALL_CAP_NEWCALL) <<

   479 			PRINT_IF_CC_CAP_TRUE(CCAPI_CALL_CAP_ANSWER) <<

   480 			PRINT_IF_CC_CAP_TRUE(CCAPI_CALL_CAP_ENDCALL) <<

   481 			PRINT_IF_CC_CAP_TRUE(CCAPI_CALL_CAP_HOLD) <<

   482 			PRINT_IF_CC_CAP_TRUE(CCAPI_CALL_CAP_RESUME) <<

   483 			PRINT_IF_CC_CAP_TRUE(CCAPI_CALL_CAP_CALLFWD) <<

   484 			PRINT_IF_CC_CAP_TRUE(CCAPI_CALL_CAP_DIAL) <<

   485 			PRINT_IF_CC_CAP_TRUE(CCAPI_CALL_CAP_BACKSPACE) <<

   486 			PRINT_IF_CC_CAP_TRUE(CCAPI_CALL_CAP_SENDDIGIT) <<

   487 			PRINT_IF_CC_CAP_TRUE(CCAPI_CALL_CAP_TRANSFER) <<

   488 			PRINT_IF_CC_CAP_TRUE(CCAPI_CALL_CAP_CONFERENCE) <<

   489 			PRINT_IF_CC_CAP_TRUE(CCAPI_CALL_CAP_SWAP) <<

   490 			PRINT_IF_CC_CAP_TRUE(CCAPI_CALL_CAP_REDIAL) <<

   491 			PRINT_IF_CC_CAP_TRUE(CCAPI_CALL_CAP_JOIN) <<

   492 			PRINT_IF_CC_CAP_TRUE(CCAPI_CALL_CAP_SELECT) <<

   493 			PRINT_IF_CC_CAP_TRUE(CCAPI_CALL_CAP_RMVLASTPARTICIPANT) );

   494 */

   495 	switch(getCallState())

   496 	{

   497 	case OFFHOOK:

   498 		if(hasFeature(CCAPI_CALL_CAP_NEWCALL)) {

   499 			caps.insert(CC_CallCapabilityEnum::canOriginateCall);

   500 		}

   501 		if(hasFeature(CCAPI_CALL_CAP_ENDCALL)) {

   502 			caps.insert(CC_CallCapabilityEnum::canEndCall);

   503 		}

   504 		break;

   505 	case ONHOOK:

   506 		break;

   507 	case DIALING:

   508 	case PROCEED:

   509 	case RINGOUT:

   510 		if(hasFeature(CCAPI_CALL_CAP_ENDCALL)) {

   511 			caps.insert(CC_CallCapabilityEnum::canEndCall);

   512 		}

   513 		if(hasFeature(CCAPI_CALL_CAP_SENDDIGIT)) caps.insert(CC_CallCapabilityEnum::canSendDigit);

   514 		break;

   515 	case RINGIN:

   516 		if(hasFeature(CCAPI_CALL_CAP_ANSWER)) caps.insert(CC_CallCapabilityEnum::canAnswerCall);

   517 		break;

   518 	case CONNECTED:

   519 		if(hasFeature(CCAPI_CALL_CAP_ENDCALL)) {

   520 			caps.insert(CC_CallCapabilityEnum::canEndCall);

   521 		}

   522 		caps.insert(CC_CallCapabilityEnum::canSendDigit);

   523 		if(hasFeature(CCAPI_CALL_CAP_HOLD)) caps.insert(CC_CallCapabilityEnum::canHold);

   524 

   525         caps.insert(CC_CallCapabilityEnum::canSetVolume);

   526 		if(isAudioMuted())

   527         {

   528             caps.insert(CC_CallCapabilityEnum::canUnmuteAudio);

   529         }

   530         else

   531         {

   532             caps.insert(CC_CallCapabilityEnum::canMuteAudio);

   533         }

   534 

   535         if ((CCAPI_CallInfo_getVideoDirection(callinfo_ref) == CC_SDP_DIRECTION_SENDRECV) ||

   536             (CCAPI_CallInfo_getVideoDirection(callinfo_ref) == CC_SDP_DIRECTION_SENDONLY))

   537         {

   538             // sending video so video mute is possible

   539             if (isVideoMuted())

   540             {

   541                 caps.insert(CC_CallCapabilityEnum::canUnmuteVideo);

   542             }

   543             else

   544             {

   545                 caps.insert(CC_CallCapabilityEnum::canMuteVideo);

   546             }

   547         }

   548         caps.insert(CC_CallCapabilityEnum::canUpdateVideoMediaCap);

   549 		break;

   550 	case HOLD:

   551 	case REMHOLD:

   552         caps.insert(CC_CallCapabilityEnum::canResume);

   553 		break;

   554 

   555 	case BUSY:

   556 	case REORDER:

   557 		if(hasFeature(CCAPI_CALL_CAP_ENDCALL)) {

   558 			caps.insert(CC_CallCapabilityEnum::canEndCall);

   559 		}

   560 		break;

   561 	case PRESERVATION:

   562 		if(hasFeature(CCAPI_CALL_CAP_ENDCALL)) {

   563 			caps.insert(CC_CallCapabilityEnum::canEndCall);

   564 		}

   565 		break;

   566 

   567 	// Not worrying about these states yet.

   568 	case RESUME:

   569 	case CONFERENCE:

   570 	case REMINUSE:

   571 	case HOLDREVERT:

   572 	case WHISPER:

   573 	case WAITINGFORDIGITS:

   574 	default:

   575 		CSFLogError( logTag, "State %d not handled in generateCapabilities()",

   576       getCallState());

   577 		break;

   578 	}

   579 }

   580 

   581 bool CC_SIPCCCallInfo::hasFeature(ccapi_call_capability_e cap)

   582 {

   583 	return (CCAPI_CallInfo_hasCapability(callinfo_ref, (cc_int32_t) cap) != 0);

   584 }

   585 

   586 void CC_SIPCCCallInfo::setMediaData(CC_SIPCCCallMediaDataPtr  pMediaData)

   587 {

   588     this-> pMediaData =  pMediaData;

   589 }

   590

Mercurial Repository: The Tor Browser

Europalab SCM Repository Server

mercurial