c:/Git/PeerCast.root/PeerCast/core/common/peercast.cpp

   1 #include "sys.h"
   2 #include "peercast.h"
   3 #include "channel.h"
   4 #include "servmgr.h"
   5 #ifdef _DEBUG
   6 #include "chkMemoryLeak.h"
   7 #define DEBUG_NEW new(__FILE__, __LINE__)
   8 #define new DEBUG_NEW
   9 #endif
  10
  11
  12
  13 // ---------------------------------
  14 // globals
  15
  16 Sys *sys=NULL;
  17 ChanMgr *chanMgr;
  18 ServMgr *servMgr;
  19
  20 PeercastInstance *peercastInst=NULL;
  21 PeercastApplication *peercastApp=NULL;
  22
  23
  24 // ---------------------------------
  25 void APICALL PeercastInstance::init()
  26 {
  27         sys = createSys();
  28         servMgr = new ServMgr();
  29         chanMgr = new ChanMgr();
  30
  31         if (peercastApp->getIniFilename())
  32                 servMgr->loadSettings(peercastApp->getIniFilename());
  33
  34         servMgr->start();
  35 }
  36 // --------------------------------------------------
  37 void    APICALL PeercastInstance::setNotifyMask(int mask)
  38 {
  39         if (servMgr)
  40                 servMgr->notifyMask = mask;
  41 }
  42 // --------------------------------------------------
  43 int             APICALL PeercastInstance::getNotifyMask()
  44 {
  45         if (servMgr)
  46                 return servMgr->notifyMask;
  47         else
  48                 return 0;
  49 }
  50
  51 // --------------------------------------------------
  52 void    APICALL PeercastInstance::setAutoConnect(bool on)
  53 {
  54         if (servMgr)
  55                 servMgr->autoConnect = on;
  56 }
  57 // --------------------------------------------------
  58 bool    APICALL PeercastInstance::getAutoConnect()
  59 {
  60         if (servMgr)
  61                 return servMgr->autoConnect;
  62         else
  63                 return false;
  64 }
  65 // --------------------------------------------------
  66 void    APICALL PeercastInstance::setMaxOutput(int kbps)
  67 {
  68         if (servMgr)
  69                 servMgr->maxBitrateOut = kbps;
  70 }
  71 // --------------------------------------------------
  72 int             APICALL PeercastInstance::getMaxOutput()
  73 {
  74         if (servMgr)
  75                 return servMgr->maxBitrateOut;
  76         else
  77                 return 0;
  78 }
  79 // --------------------------------------------------
  80 void    APICALL PeercastInstance::setMaxRelays(int max)
  81 {
  82         if (servMgr)
  83                 servMgr->setMaxRelays(max);
  84 }
  85 // --------------------------------------------------
  86 int             APICALL PeercastInstance::getMaxRelays()
  87 {
  88         if (servMgr)
  89                 return servMgr->maxRelays;
  90         else
  91                 return 0;
  92 }
  93 // --------------------------------------------------
  94 void    APICALL PeercastInstance::setActive(bool on)
  95 {
  96         if (servMgr)
  97         {
  98                 servMgr->autoConnect = on;
  99                 servMgr->autoServe = on;
 100         }
 101 }
 102 // --------------------------------------------------
 103 bool    APICALL PeercastInstance::getActive()
 104 {
 105         if (servMgr)
 106                 return servMgr->autoConnect&&servMgr->autoServe;
 107         else
 108                 return false;
 109 }
 110 // --------------------------------------------------
 111 void    APICALL PeercastInstance::saveSettings()
 112 {
 113         if (servMgr)
 114                 servMgr->saveSettings(peercastApp->getIniFilename());
 115 }
 116 // --------------------------------------------------
 117 void    APICALL PeercastInstance::quit()
 118 {
 119         isQuitting = true;
 120         if (chanMgr)
 121                 chanMgr->quit();
 122         if (servMgr)
 123                 servMgr->quit();
 124 }
 125 // --------------------------------------------------
 126 void    APICALL PeercastInstance::setServerPort(int port)
 127 {
 128         if (servMgr)
 129         {
 130                 servMgr->serverHost.port = port;
 131                 servMgr->restartServer = true;
 132         }
 133 }
 134 // --------------------------------------------------
 135 int             APICALL PeercastInstance::getServerPort()
 136 {
 137         if (servMgr)
 138                 return servMgr->serverHost.port;
 139         else
 140                 return 0;
 141 }
 142 // --------------------------------------------------
 143 void    APICALL PeercastInstance::setServerPassword(const char *pwd)
 144 {
 145         if (servMgr)
 146                 strcpy(servMgr->password,pwd);
 147 }
 148 // --------------------------------------------------
 149 const char *APICALL     PeercastInstance::getServerPassword()
 150 {
 151         return servMgr->password;
 152 }
 153 // --------------------------------------------------
 154 void    APICALL PeercastInstance::callLocalURL(const char *url)
 155 {
 156         if (sys && servMgr)
 157                 sys->callLocalURL(url,servMgr->serverHost.port);
 158 }
 159
 160
 161 // --------------------------------------------------
 162 void ADDLOG(const char *fmt,va_list ap,LogBuffer::TYPE type)
 163 {
 164         if(sys)
 165         {
 166                 const int MAX_LINELEN = 1024;
 167
 168                 char str[MAX_LINELEN+1];
 169                 vsnprintf(str,MAX_LINELEN-1,fmt,ap);
 170                 str[MAX_LINELEN-1]=0;
 171
 172                 if (type != LogBuffer::T_NONE)
 173                         sys->logBuf->write(str,type);
 174
 175                 peercastApp->printLog(type,str);
 176         }
 177 }
 178 // --------------------------------------------------
 179 void LOG(const char *fmt,...)
 180 {
 181         va_list ap;
 182         va_start(ap, fmt);
 183         ADDLOG(fmt,ap,LogBuffer::T_DEBUG);
 184         va_end(ap);
 185 }
 186
 187 // --------------------------------------------------
 188 void LOG_ERROR(const char *fmt,...)
 189 {
 190         if (servMgr)
 191         {
 192                 if ((servMgr->showLog & (1<<LogBuffer::T_ERROR)) && (!servMgr->pauseLog))
 193                 {
 194                         va_list ap;
 195                         va_start(ap, fmt);
 196                         ADDLOG(fmt,ap,LogBuffer::T_ERROR);
 197                         va_end(ap);
 198                 }
 199         }
 200 }
 201 // --------------------------------------------------
 202 void LOG_DEBUG(const char *fmt,...)
 203 {
 204         if (servMgr)
 205         {
 206                 if ((servMgr->showLog & (1<<LogBuffer::T_DEBUG)) && (!servMgr->pauseLog))
 207                 {
 208                         va_list ap;
 209                         va_start(ap, fmt);
 210                         ADDLOG(fmt,ap,LogBuffer::T_DEBUG);
 211                         va_end(ap);
 212                 }
 213         }
 214 }
 215 // --------------------------------------------------
 216 void LOG_NETWORK(const char *fmt,...)
 217 {
 218         if (servMgr)
 219         {
 220                 if ((servMgr->showLog & (1<<LogBuffer::T_NETWORK)) && (!servMgr->pauseLog))
 221                 {
 222                         va_list ap;
 223                         va_start(ap, fmt);
 224                         ADDLOG(fmt,ap,LogBuffer::T_NETWORK);
 225                         va_end(ap);
 226                 }
 227         }
 228 }
 229 // --------------------------------------------------
 230 void LOG_CHANNEL(const char *fmt,...)
 231 {
 232         if (servMgr)
 233         {
 234                 if ((servMgr->showLog & (1<<LogBuffer::T_CHANNEL)) && (!servMgr->pauseLog))
 235                 {
 236                         va_list ap;
 237                         va_start(ap, fmt);
 238                         ADDLOG(fmt,ap,LogBuffer::T_CHANNEL);
 239                         va_end(ap);
 240                 }
 241         }
 242 }