src/kits/network/libnetapi/UrlRequest.cpp

   1 /*
   2  * Copyright 2010 Haiku Inc. All rights reserved.
   3  * Distributed under the terms of the MIT License.
   4  *
   5  * Authors:
   6  *              Christophe Huriaux, c.huriaux@gmail.com
   7  */
   8
   9
  10 #include <UrlRequest.h>
  11 #include <Debug.h>
  12 #include <stdio.h>
  13
  14
  15 static BReference<BUrlContext> gDefaultContext = new(std::nothrow) BUrlContext();
  16
  17
  18 BUrlRequest::BUrlRequest(const BUrl& url, BUrlProtocolListener* listener,
  19         BUrlContext* context, const char* threadName, const char* protocolName)
  20         :
  21         fUrl(url),
  22         fContext(context),
  23         fListener(listener),
  24         fQuit(false),
  25         fRunning(false),
  26         fThreadStatus(B_NO_INIT),
  27         fThreadId(0),
  28         fThreadName(threadName),
  29         fProtocol(protocolName)
  30 {
  31         if (fContext == NULL)
  32                 fContext = gDefaultContext;
  33 }
  34
  35
  36 BUrlRequest::~BUrlRequest()
  37 {
  38         Stop();
  39 }
  40
  41
  42 // #pragma mark URL protocol thread management
  43
  44
  45 thread_id
  46 BUrlRequest::Run()
  47 {
  48         // Thread already running
  49         if (fRunning) {
  50                 PRINT(("BUrlRequest::Run() : Oops, already running ! "
  51                         "[urlProtocol=%p]!\n", this));
  52                 return fThreadId;
  53         }
  54
  55         fThreadId = spawn_thread(BUrlRequest::_ThreadEntry, fThreadName,
  56                 B_NORMAL_PRIORITY, this);
  57
  58         if (fThreadId < B_OK)
  59                 return fThreadId;
  60
  61         fRunning = true;
  62
  63         status_t launchErr = resume_thread(fThreadId);
  64         if (launchErr < B_OK) {
  65                 PRINT(("BUrlRequest::Run() : Failed to resume thread %" B_PRId32 "\n",
  66                         fThreadId));
  67                 return launchErr;
  68         }
  69
  70         return fThreadId;
  71 }
  72
  73
  74 status_t
  75 BUrlRequest::Pause()
  76 {
  77         // TODO
  78         return B_ERROR;
  79 }
  80
  81
  82 status_t
  83 BUrlRequest::Resume()
  84 {
  85         // TODO
  86         return B_ERROR;
  87 }
  88
  89
  90 status_t
  91 BUrlRequest::Stop()
  92 {
  93         if (!fRunning)
  94                 return B_ERROR;
  95
  96         fQuit = true;
  97         return B_OK;
  98 }
  99
 100
 101 // #pragma mark URL protocol parameters modification
 102
 103
 104 status_t
 105 BUrlRequest::SetUrl(const BUrl& url)
 106 {
 107         // We should avoid to change URL while the thread is running ...
 108         if (IsRunning())
 109                 return B_ERROR;
 110
 111         fUrl = url;
 112         return B_OK;
 113 }
 114
 115
 116 status_t
 117 BUrlRequest::SetContext(BUrlContext* context)
 118 {
 119         if (IsRunning())
 120                 return B_ERROR;
 121
 122         fContext = context;
 123         return B_OK;
 124 }
 125
 126
 127 status_t
 128 BUrlRequest::SetListener(BUrlProtocolListener* listener)
 129 {
 130         if (IsRunning())
 131                 return B_ERROR;
 132
 133         fListener = listener;
 134         return B_OK;
 135 }
 136
 137
 138 // #pragma mark URL protocol parameters access
 139
 140
 141 const BUrl&
 142 BUrlRequest::Url() const
 143 {
 144         return fUrl;
 145 }
 146
 147
 148 BUrlContext*
 149 BUrlRequest::Context() const
 150 {
 151         return fContext;
 152 }
 153
 154
 155 BUrlProtocolListener*
 156 BUrlRequest::Listener() const
 157 {
 158         return fListener;
 159 }
 160
 161
 162 const BString&
 163 BUrlRequest::Protocol() const
 164 {
 165         return fProtocol;
 166 }
 167
 168
 169 // #pragma mark URL protocol informations
 170
 171
 172 bool
 173 BUrlRequest::IsRunning() const
 174 {
 175         return fRunning;
 176 }
 177
 178
 179 status_t
 180 BUrlRequest::Status() const
 181 {
 182         return fThreadStatus;
 183 }
 184
 185
 186 // #pragma mark Thread management
 187
 188
 189 /*static*/ int32
 190 BUrlRequest::_ThreadEntry(void* arg)
 191 {
 192         BUrlRequest* request = reinterpret_cast<BUrlRequest*>(arg);
 193         request->fThreadStatus = B_BUSY;
 194         request->_ProtocolSetup();
 195
 196         status_t protocolLoopExitStatus = request->_ProtocolLoop();
 197
 198         request->fRunning = false;
 199         request->fThreadStatus = protocolLoopExitStatus;
 200
 201         if (request->fListener != NULL) {
 202                 request->fListener->RequestCompleted(request,
 203                         protocolLoopExitStatus == B_OK);
 204         }
 205
 206         return B_OK;
 207 }
 208
 209
 210 void
 211 BUrlRequest::_EmitDebug(BUrlProtocolDebugMessage type,
 212         const char* format, ...)
 213 {
 214         if (fListener == NULL)
 215                 return;
 216
 217         va_list arguments;
 218         va_start(arguments, format);
 219
 220         char debugMsg[1024];
 221         vsnprintf(debugMsg, sizeof(debugMsg), format, arguments);
 222         fListener->DebugMessage(this, type, debugMsg);
 223         va_end(arguments);
 224 }