1/*
2 * Copyright (C) 2010 The Android Open Source Project
3 *
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at
7 *
8 *      http://www.apache.org/licenses/LICENSE-2.0
9 *
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
15 */
16
17//#define LOG_NDEBUG 0
18#define LOG_TAG "ARTSPConnection"
19#include <utils/Log.h>
20
21#include "ARTSPConnection.h"
22
23#include <media/stagefright/foundation/ABuffer.h>
24#include <media/stagefright/foundation/ADebug.h>
25#include <media/stagefright/foundation/AMessage.h>
26#include <media/stagefright/foundation/base64.h>
27#include <media/stagefright/MediaErrors.h>
28#include <media/stagefright/Utils.h>
29
30#include <arpa/inet.h>
31#include <fcntl.h>
32#include <netdb.h>
33#include <openssl/md5.h>
34#include <sys/socket.h>
35
36#include "include/HTTPBase.h"
37
38namespace android {
39
40// static
41const int64_t ARTSPConnection::kSelectTimeoutUs = 1000ll;
42
43// static
44const AString ARTSPConnection::sUserAgent =
45    StringPrintf("User-Agent: %s\r\n", MakeUserAgent().c_str());
46
47ARTSPConnection::ARTSPConnection(bool uidValid, uid_t uid)
48    : mUIDValid(uidValid),
49      mUID(uid),
50      mState(DISCONNECTED),
51      mAuthType(NONE),
52      mSocket(-1),
53      mConnectionID(0),
54      mNextCSeq(0),
55      mReceiveResponseEventPending(false) {
56}
57
58ARTSPConnection::~ARTSPConnection() {
59    if (mSocket >= 0) {
60        ALOGE("Connection is still open, closing the socket.");
61        if (mUIDValid) {
62            HTTPBase::UnRegisterSocketUserTag(mSocket);
63            HTTPBase::UnRegisterSocketUserMark(mSocket);
64        }
65        close(mSocket);
66        mSocket = -1;
67    }
68}
69
70void ARTSPConnection::connect(const char *url, const sp<AMessage> &reply) {
71    sp<AMessage> msg = new AMessage(kWhatConnect, id());
72    msg->setString("url", url);
73    msg->setMessage("reply", reply);
74    msg->post();
75}
76
77void ARTSPConnection::disconnect(const sp<AMessage> &reply) {
78    sp<AMessage> msg = new AMessage(kWhatDisconnect, id());
79    msg->setMessage("reply", reply);
80    msg->post();
81}
82
83void ARTSPConnection::sendRequest(
84        const char *request, const sp<AMessage> &reply) {
85    sp<AMessage> msg = new AMessage(kWhatSendRequest, id());
86    msg->setString("request", request);
87    msg->setMessage("reply", reply);
88    msg->post();
89}
90
91void ARTSPConnection::observeBinaryData(const sp<AMessage> &reply) {
92    sp<AMessage> msg = new AMessage(kWhatObserveBinaryData, id());
93    msg->setMessage("reply", reply);
94    msg->post();
95}
96
97void ARTSPConnection::onMessageReceived(const sp<AMessage> &msg) {
98    switch (msg->what()) {
99        case kWhatConnect:
100            onConnect(msg);
101            break;
102
103        case kWhatDisconnect:
104            onDisconnect(msg);
105            break;
106
107        case kWhatCompleteConnection:
108            onCompleteConnection(msg);
109            break;
110
111        case kWhatSendRequest:
112            onSendRequest(msg);
113            break;
114
115        case kWhatReceiveResponse:
116            onReceiveResponse();
117            break;
118
119        case kWhatObserveBinaryData:
120        {
121            CHECK(msg->findMessage("reply", &mObserveBinaryMessage));
122            break;
123        }
124
125        default:
126            TRESPASS();
127            break;
128    }
129}
130
131// static
132bool ARTSPConnection::ParseURL(
133        const char *url, AString *host, unsigned *port, AString *path,
134        AString *user, AString *pass) {
135    host->clear();
136    *port = 0;
137    path->clear();
138    user->clear();
139    pass->clear();
140
141    if (strncasecmp("rtsp://", url, 7)) {
142        return false;
143    }
144
145    const char *slashPos = strchr(&url[7], '/');
146
147    if (slashPos == NULL) {
148        host->setTo(&url[7]);
149        path->setTo("/");
150    } else {
151        host->setTo(&url[7], slashPos - &url[7]);
152        path->setTo(slashPos);
153    }
154
155    ssize_t atPos = host->find("@");
156
157    if (atPos >= 0) {
158        // Split of user:pass@ from hostname.
159
160        AString userPass(*host, 0, atPos);
161        host->erase(0, atPos + 1);
162
163        ssize_t colonPos = userPass.find(":");
164
165        if (colonPos < 0) {
166            *user = userPass;
167        } else {
168            user->setTo(userPass, 0, colonPos);
169            pass->setTo(userPass, colonPos + 1, userPass.size() - colonPos - 1);
170        }
171    }
172
173    const char *colonPos = strchr(host->c_str(), ':');
174
175    if (colonPos != NULL) {
176        unsigned long x;
177        if (!ParseSingleUnsignedLong(colonPos + 1, &x) || x >= 65536) {
178            return false;
179        }
180
181        *port = x;
182
183        size_t colonOffset = colonPos - host->c_str();
184        size_t trailing = host->size() - colonOffset;
185        host->erase(colonOffset, trailing);
186    } else {
187        *port = 554;
188    }
189
190    return true;
191}
192
193static status_t MakeSocketBlocking(int s, bool blocking) {
194    // Make socket non-blocking.
195    int flags = fcntl(s, F_GETFL, 0);
196
197    if (flags == -1) {
198        return UNKNOWN_ERROR;
199    }
200
201    if (blocking) {
202        flags &= ~O_NONBLOCK;
203    } else {
204        flags |= O_NONBLOCK;
205    }
206
207    flags = fcntl(s, F_SETFL, flags);
208
209    return flags == -1 ? UNKNOWN_ERROR : OK;
210}
211
212void ARTSPConnection::onConnect(const sp<AMessage> &msg) {
213    ++mConnectionID;
214
215    if (mState != DISCONNECTED) {
216        if (mUIDValid) {
217            HTTPBase::UnRegisterSocketUserTag(mSocket);
218            HTTPBase::UnRegisterSocketUserMark(mSocket);
219        }
220        close(mSocket);
221        mSocket = -1;
222
223        flushPendingRequests();
224    }
225
226    mState = CONNECTING;
227
228    AString url;
229    CHECK(msg->findString("url", &url));
230
231    sp<AMessage> reply;
232    CHECK(msg->findMessage("reply", &reply));
233
234    AString host, path;
235    unsigned port;
236    if (!ParseURL(url.c_str(), &host, &port, &path, &mUser, &mPass)
237            || (mUser.size() > 0 && mPass.size() == 0)) {
238        // If we have a user name but no password we have to give up
239        // right here, since we currently have no way of asking the user
240        // for this information.
241
242        ALOGE("Malformed rtsp url %s", uriDebugString(url).c_str());
243
244        reply->setInt32("result", ERROR_MALFORMED);
245        reply->post();
246
247        mState = DISCONNECTED;
248        return;
249    }
250
251    if (mUser.size() > 0) {
252        ALOGV("user = '%s', pass = '%s'", mUser.c_str(), mPass.c_str());
253    }
254
255    struct hostent *ent = gethostbyname(host.c_str());
256    if (ent == NULL) {
257        ALOGE("Unknown host %s", host.c_str());
258
259        reply->setInt32("result", -ENOENT);
260        reply->post();
261
262        mState = DISCONNECTED;
263        return;
264    }
265
266    mSocket = socket(AF_INET, SOCK_STREAM, 0);
267
268    if (mUIDValid) {
269        HTTPBase::RegisterSocketUserTag(mSocket, mUID,
270                                        (uint32_t)*(uint32_t*) "RTSP");
271        HTTPBase::RegisterSocketUserMark(mSocket, mUID);
272    }
273
274    MakeSocketBlocking(mSocket, false);
275
276    struct sockaddr_in remote;
277    memset(remote.sin_zero, 0, sizeof(remote.sin_zero));
278    remote.sin_family = AF_INET;
279    remote.sin_addr.s_addr = *(in_addr_t *)ent->h_addr;
280    remote.sin_port = htons(port);
281
282    int err = ::connect(
283            mSocket, (const struct sockaddr *)&remote, sizeof(remote));
284
285    reply->setInt32("server-ip", ntohl(remote.sin_addr.s_addr));
286
287    if (err < 0) {
288        if (errno == EINPROGRESS) {
289            sp<AMessage> msg = new AMessage(kWhatCompleteConnection, id());
290            msg->setMessage("reply", reply);
291            msg->setInt32("connection-id", mConnectionID);
292            msg->post();
293            return;
294        }
295
296        reply->setInt32("result", -errno);
297        mState = DISCONNECTED;
298
299        if (mUIDValid) {
300            HTTPBase::UnRegisterSocketUserTag(mSocket);
301            HTTPBase::UnRegisterSocketUserMark(mSocket);
302        }
303        close(mSocket);
304        mSocket = -1;
305    } else {
306        reply->setInt32("result", OK);
307        mState = CONNECTED;
308        mNextCSeq = 1;
309
310        postReceiveReponseEvent();
311    }
312
313    reply->post();
314}
315
316void ARTSPConnection::performDisconnect() {
317    if (mUIDValid) {
318        HTTPBase::UnRegisterSocketUserTag(mSocket);
319        HTTPBase::UnRegisterSocketUserMark(mSocket);
320    }
321    close(mSocket);
322    mSocket = -1;
323
324    flushPendingRequests();
325
326    mUser.clear();
327    mPass.clear();
328    mAuthType = NONE;
329    mNonce.clear();
330
331    mState = DISCONNECTED;
332}
333
334void ARTSPConnection::onDisconnect(const sp<AMessage> &msg) {
335    if (mState == CONNECTED || mState == CONNECTING) {
336        performDisconnect();
337    }
338
339    sp<AMessage> reply;
340    CHECK(msg->findMessage("reply", &reply));
341
342    reply->setInt32("result", OK);
343
344    reply->post();
345}
346
347void ARTSPConnection::onCompleteConnection(const sp<AMessage> &msg) {
348    sp<AMessage> reply;
349    CHECK(msg->findMessage("reply", &reply));
350
351    int32_t connectionID;
352    CHECK(msg->findInt32("connection-id", &connectionID));
353
354    if ((connectionID != mConnectionID) || mState != CONNECTING) {
355        // While we were attempting to connect, the attempt was
356        // cancelled.
357        reply->setInt32("result", -ECONNABORTED);
358        reply->post();
359        return;
360    }
361
362    struct timeval tv;
363    tv.tv_sec = 0;
364    tv.tv_usec = kSelectTimeoutUs;
365
366    fd_set ws;
367    FD_ZERO(&ws);
368    FD_SET(mSocket, &ws);
369
370    int res = select(mSocket + 1, NULL, &ws, NULL, &tv);
371    CHECK_GE(res, 0);
372
373    if (res == 0) {
374        // Timed out. Not yet connected.
375
376        msg->post();
377        return;
378    }
379
380    int err;
381    socklen_t optionLen = sizeof(err);
382    CHECK_EQ(getsockopt(mSocket, SOL_SOCKET, SO_ERROR, &err, &optionLen), 0);
383    CHECK_EQ(optionLen, (socklen_t)sizeof(err));
384
385    if (err != 0) {
386        ALOGE("err = %d (%s)", err, strerror(err));
387
388        reply->setInt32("result", -err);
389
390        mState = DISCONNECTED;
391        if (mUIDValid) {
392            HTTPBase::UnRegisterSocketUserTag(mSocket);
393            HTTPBase::UnRegisterSocketUserMark(mSocket);
394        }
395        close(mSocket);
396        mSocket = -1;
397    } else {
398        reply->setInt32("result", OK);
399        mState = CONNECTED;
400        mNextCSeq = 1;
401
402        postReceiveReponseEvent();
403    }
404
405    reply->post();
406}
407
408void ARTSPConnection::onSendRequest(const sp<AMessage> &msg) {
409    sp<AMessage> reply;
410    CHECK(msg->findMessage("reply", &reply));
411
412    if (mState != CONNECTED) {
413        reply->setInt32("result", -ENOTCONN);
414        reply->post();
415        return;
416    }
417
418    AString request;
419    CHECK(msg->findString("request", &request));
420
421    // Just in case we need to re-issue the request with proper authentication
422    // later, stash it away.
423    reply->setString("original-request", request.c_str(), request.size());
424
425    addAuthentication(&request);
426    addUserAgent(&request);
427
428    // Find the boundary between headers and the body.
429    ssize_t i = request.find("\r\n\r\n");
430    CHECK_GE(i, 0);
431
432    int32_t cseq = mNextCSeq++;
433
434    AString cseqHeader = "CSeq: ";
435    cseqHeader.append(cseq);
436    cseqHeader.append("\r\n");
437
438    request.insert(cseqHeader, i + 2);
439
440    ALOGV("request: '%s'", request.c_str());
441
442    size_t numBytesSent = 0;
443    while (numBytesSent < request.size()) {
444        ssize_t n =
445            send(mSocket, request.c_str() + numBytesSent,
446                 request.size() - numBytesSent, 0);
447
448        if (n < 0 && errno == EINTR) {
449            continue;
450        }
451
452        if (n <= 0) {
453            performDisconnect();
454
455            if (n == 0) {
456                // Server closed the connection.
457                ALOGE("Server unexpectedly closed the connection.");
458
459                reply->setInt32("result", ERROR_IO);
460                reply->post();
461            } else {
462                ALOGE("Error sending rtsp request. (%s)", strerror(errno));
463                reply->setInt32("result", -errno);
464                reply->post();
465            }
466
467            return;
468        }
469
470        numBytesSent += (size_t)n;
471    }
472
473    mPendingRequests.add(cseq, reply);
474}
475
476void ARTSPConnection::onReceiveResponse() {
477    mReceiveResponseEventPending = false;
478
479    if (mState != CONNECTED) {
480        return;
481    }
482
483    struct timeval tv;
484    tv.tv_sec = 0;
485    tv.tv_usec = kSelectTimeoutUs;
486
487    fd_set rs;
488    FD_ZERO(&rs);
489    FD_SET(mSocket, &rs);
490
491    int res = select(mSocket + 1, &rs, NULL, NULL, &tv);
492
493    if (res == 1) {
494        MakeSocketBlocking(mSocket, true);
495
496        bool success = receiveRTSPReponse();
497
498        MakeSocketBlocking(mSocket, false);
499
500        if (!success) {
501            // Something horrible, irreparable has happened.
502            flushPendingRequests();
503            return;
504        }
505    }
506
507    postReceiveReponseEvent();
508}
509
510void ARTSPConnection::flushPendingRequests() {
511    for (size_t i = 0; i < mPendingRequests.size(); ++i) {
512        sp<AMessage> reply = mPendingRequests.valueAt(i);
513
514        reply->setInt32("result", -ECONNABORTED);
515        reply->post();
516    }
517
518    mPendingRequests.clear();
519}
520
521void ARTSPConnection::postReceiveReponseEvent() {
522    if (mReceiveResponseEventPending) {
523        return;
524    }
525
526    sp<AMessage> msg = new AMessage(kWhatReceiveResponse, id());
527    msg->post();
528
529    mReceiveResponseEventPending = true;
530}
531
532status_t ARTSPConnection::receive(void *data, size_t size) {
533    size_t offset = 0;
534    while (offset < size) {
535        ssize_t n = recv(mSocket, (uint8_t *)data + offset, size - offset, 0);
536
537        if (n < 0 && errno == EINTR) {
538            continue;
539        }
540
541        if (n <= 0) {
542            performDisconnect();
543
544            if (n == 0) {
545                // Server closed the connection.
546                ALOGE("Server unexpectedly closed the connection.");
547                return ERROR_IO;
548            } else {
549                ALOGE("Error reading rtsp response. (%s)", strerror(errno));
550                return -errno;
551            }
552        }
553
554        offset += (size_t)n;
555    }
556
557    return OK;
558}
559
560bool ARTSPConnection::receiveLine(AString *line) {
561    line->clear();
562
563    bool sawCR = false;
564    for (;;) {
565        char c;
566        if (receive(&c, 1) != OK) {
567            return false;
568        }
569
570        if (sawCR && c == '\n') {
571            line->erase(line->size() - 1, 1);
572            return true;
573        } else if (c == '\n') {
574            // some reponse line ended with '\n', instead of '\r\n'.
575            return true;
576        }
577
578        line->append(&c, 1);
579
580        if (c == '$' && line->size() == 1) {
581            // Special-case for interleaved binary data.
582            return true;
583        }
584
585        sawCR = (c == '\r');
586    }
587}
588
589sp<ABuffer> ARTSPConnection::receiveBinaryData() {
590    uint8_t x[3];
591    if (receive(x, 3) != OK) {
592        return NULL;
593    }
594
595    sp<ABuffer> buffer = new ABuffer((x[1] << 8) | x[2]);
596    if (receive(buffer->data(), buffer->size()) != OK) {
597        return NULL;
598    }
599
600    buffer->meta()->setInt32("index", (int32_t)x[0]);
601
602    return buffer;
603}
604
605static bool IsRTSPVersion(const AString &s) {
606    return s == "RTSP/1.0";
607}
608
609bool ARTSPConnection::receiveRTSPReponse() {
610    AString statusLine;
611
612    if (!receiveLine(&statusLine)) {
613        return false;
614    }
615
616    if (statusLine == "$") {
617        sp<ABuffer> buffer = receiveBinaryData();
618
619        if (buffer == NULL) {
620            return false;
621        }
622
623        if (mObserveBinaryMessage != NULL) {
624            sp<AMessage> notify = mObserveBinaryMessage->dup();
625            notify->setBuffer("buffer", buffer);
626            notify->post();
627        } else {
628            ALOGW("received binary data, but no one cares.");
629        }
630
631        return true;
632    }
633
634    sp<ARTSPResponse> response = new ARTSPResponse;
635    response->mStatusLine = statusLine;
636
637    ALOGI("status: %s", response->mStatusLine.c_str());
638
639    ssize_t space1 = response->mStatusLine.find(" ");
640    if (space1 < 0) {
641        return false;
642    }
643    ssize_t space2 = response->mStatusLine.find(" ", space1 + 1);
644    if (space2 < 0) {
645        return false;
646    }
647
648    bool isRequest = false;
649
650    if (!IsRTSPVersion(AString(response->mStatusLine, 0, space1))) {
651        CHECK(IsRTSPVersion(
652                    AString(
653                        response->mStatusLine,
654                        space2 + 1,
655                        response->mStatusLine.size() - space2 - 1)));
656
657        isRequest = true;
658
659        response->mStatusCode = 0;
660    } else {
661        AString statusCodeStr(
662                response->mStatusLine, space1 + 1, space2 - space1 - 1);
663
664        if (!ParseSingleUnsignedLong(
665                    statusCodeStr.c_str(), &response->mStatusCode)
666                || response->mStatusCode < 100 || response->mStatusCode > 999) {
667            return false;
668        }
669    }
670
671    AString line;
672    ssize_t lastDictIndex = -1;
673    for (;;) {
674        if (!receiveLine(&line)) {
675            break;
676        }
677
678        if (line.empty()) {
679            break;
680        }
681
682        ALOGV("line: '%s'", line.c_str());
683
684        if (line.c_str()[0] == ' ' || line.c_str()[0] == '\t') {
685            // Support for folded header values.
686
687            if (lastDictIndex < 0) {
688                // First line cannot be a continuation of the previous one.
689                return false;
690            }
691
692            AString &value = response->mHeaders.editValueAt(lastDictIndex);
693            value.append(line);
694
695            continue;
696        }
697
698        ssize_t colonPos = line.find(":");
699        if (colonPos < 0) {
700            // Malformed header line.
701            return false;
702        }
703
704        AString key(line, 0, colonPos);
705        key.trim();
706        key.tolower();
707
708        line.erase(0, colonPos + 1);
709
710        lastDictIndex = response->mHeaders.add(key, line);
711    }
712
713    for (size_t i = 0; i < response->mHeaders.size(); ++i) {
714        response->mHeaders.editValueAt(i).trim();
715    }
716
717    unsigned long contentLength = 0;
718
719    ssize_t i = response->mHeaders.indexOfKey("content-length");
720
721    if (i >= 0) {
722        AString value = response->mHeaders.valueAt(i);
723        if (!ParseSingleUnsignedLong(value.c_str(), &contentLength)) {
724            return false;
725        }
726    }
727
728    if (contentLength > 0) {
729        response->mContent = new ABuffer(contentLength);
730
731        if (receive(response->mContent->data(), contentLength) != OK) {
732            return false;
733        }
734    }
735
736    if (response->mStatusCode == 401) {
737        if (mAuthType == NONE && mUser.size() > 0
738                && parseAuthMethod(response)) {
739            ssize_t i;
740            CHECK_EQ((status_t)OK, findPendingRequest(response, &i));
741            CHECK_GE(i, 0);
742
743            sp<AMessage> reply = mPendingRequests.valueAt(i);
744            mPendingRequests.removeItemsAt(i);
745
746            AString request;
747            CHECK(reply->findString("original-request", &request));
748
749            sp<AMessage> msg = new AMessage(kWhatSendRequest, id());
750            msg->setMessage("reply", reply);
751            msg->setString("request", request.c_str(), request.size());
752
753            ALOGI("re-sending request with authentication headers...");
754            onSendRequest(msg);
755
756            return true;
757        }
758    }
759
760    return isRequest
761        ? handleServerRequest(response)
762        : notifyResponseListener(response);
763}
764
765bool ARTSPConnection::handleServerRequest(const sp<ARTSPResponse> &request) {
766    // Implementation of server->client requests is optional for all methods
767    // but we do need to respond, even if it's just to say that we don't
768    // support the method.
769
770    ssize_t space1 = request->mStatusLine.find(" ");
771    CHECK_GE(space1, 0);
772
773    AString response;
774    response.append("RTSP/1.0 501 Not Implemented\r\n");
775
776    ssize_t i = request->mHeaders.indexOfKey("cseq");
777
778    if (i >= 0) {
779        AString value = request->mHeaders.valueAt(i);
780
781        unsigned long cseq;
782        if (!ParseSingleUnsignedLong(value.c_str(), &cseq)) {
783            return false;
784        }
785
786        response.append("CSeq: ");
787        response.append(cseq);
788        response.append("\r\n");
789    }
790
791    response.append("\r\n");
792
793    size_t numBytesSent = 0;
794    while (numBytesSent < response.size()) {
795        ssize_t n =
796            send(mSocket, response.c_str() + numBytesSent,
797                 response.size() - numBytesSent, 0);
798
799        if (n < 0 && errno == EINTR) {
800            continue;
801        }
802
803        if (n <= 0) {
804            if (n == 0) {
805                // Server closed the connection.
806                ALOGE("Server unexpectedly closed the connection.");
807            } else {
808                ALOGE("Error sending rtsp response (%s).", strerror(errno));
809            }
810
811            performDisconnect();
812
813            return false;
814        }
815
816        numBytesSent += (size_t)n;
817    }
818
819    return true;
820}
821
822// static
823bool ARTSPConnection::ParseSingleUnsignedLong(
824        const char *from, unsigned long *x) {
825    char *end;
826    *x = strtoul(from, &end, 10);
827
828    if (end == from || *end != '\0') {
829        return false;
830    }
831
832    return true;
833}
834
835status_t ARTSPConnection::findPendingRequest(
836        const sp<ARTSPResponse> &response, ssize_t *index) const {
837    *index = 0;
838
839    ssize_t i = response->mHeaders.indexOfKey("cseq");
840
841    if (i < 0) {
842        // This is an unsolicited server->client message.
843        *index = -1;
844        return OK;
845    }
846
847    AString value = response->mHeaders.valueAt(i);
848
849    unsigned long cseq;
850    if (!ParseSingleUnsignedLong(value.c_str(), &cseq)) {
851        return ERROR_MALFORMED;
852    }
853
854    i = mPendingRequests.indexOfKey(cseq);
855
856    if (i < 0) {
857        return -ENOENT;
858    }
859
860    *index = i;
861
862    return OK;
863}
864
865bool ARTSPConnection::notifyResponseListener(
866        const sp<ARTSPResponse> &response) {
867    ssize_t i;
868    status_t err = findPendingRequest(response, &i);
869
870    if (err == OK && i < 0) {
871        // An unsolicited server response is not a problem.
872        return true;
873    }
874
875    if (err != OK) {
876        return false;
877    }
878
879    sp<AMessage> reply = mPendingRequests.valueAt(i);
880    mPendingRequests.removeItemsAt(i);
881
882    reply->setInt32("result", OK);
883    reply->setObject("response", response);
884    reply->post();
885
886    return true;
887}
888
889bool ARTSPConnection::parseAuthMethod(const sp<ARTSPResponse> &response) {
890    ssize_t i = response->mHeaders.indexOfKey("www-authenticate");
891
892    if (i < 0) {
893        return false;
894    }
895
896    AString value = response->mHeaders.valueAt(i);
897
898    if (!strncmp(value.c_str(), "Basic", 5)) {
899        mAuthType = BASIC;
900    } else {
901#if !defined(HAVE_ANDROID_OS)
902        // We don't have access to the MD5 implementation on the simulator,
903        // so we won't support digest authentication.
904        return false;
905#endif
906
907        CHECK(!strncmp(value.c_str(), "Digest", 6));
908        mAuthType = DIGEST;
909
910        i = value.find("nonce=");
911        CHECK_GE(i, 0);
912        CHECK_EQ(value.c_str()[i + 6], '\"');
913        ssize_t j = value.find("\"", i + 7);
914        CHECK_GE(j, 0);
915
916        mNonce.setTo(value, i + 7, j - i - 7);
917    }
918
919    return true;
920}
921
922#if defined(HAVE_ANDROID_OS)
923static void H(const AString &s, AString *out) {
924    out->clear();
925
926    MD5_CTX m;
927    MD5_Init(&m);
928    MD5_Update(&m, s.c_str(), s.size());
929
930    uint8_t key[16];
931    MD5_Final(key, &m);
932
933    for (size_t i = 0; i < 16; ++i) {
934        char nibble = key[i] >> 4;
935        if (nibble <= 9) {
936            nibble += '0';
937        } else {
938            nibble += 'a' - 10;
939        }
940        out->append(&nibble, 1);
941
942        nibble = key[i] & 0x0f;
943        if (nibble <= 9) {
944            nibble += '0';
945        } else {
946            nibble += 'a' - 10;
947        }
948        out->append(&nibble, 1);
949    }
950}
951#endif
952
953static void GetMethodAndURL(
954        const AString &request, AString *method, AString *url) {
955    ssize_t space1 = request.find(" ");
956    CHECK_GE(space1, 0);
957
958    ssize_t space2 = request.find(" ", space1 + 1);
959    CHECK_GE(space2, 0);
960
961    method->setTo(request, 0, space1);
962    url->setTo(request, space1 + 1, space2 - space1);
963}
964
965void ARTSPConnection::addAuthentication(AString *request) {
966    if (mAuthType == NONE) {
967        return;
968    }
969
970    // Find the boundary between headers and the body.
971    ssize_t i = request->find("\r\n\r\n");
972    CHECK_GE(i, 0);
973
974    if (mAuthType == BASIC) {
975        AString tmp;
976        tmp.append(mUser);
977        tmp.append(":");
978        tmp.append(mPass);
979
980        AString out;
981        encodeBase64(tmp.c_str(), tmp.size(), &out);
982
983        AString fragment;
984        fragment.append("Authorization: Basic ");
985        fragment.append(out);
986        fragment.append("\r\n");
987
988        request->insert(fragment, i + 2);
989
990        return;
991    }
992
993#if defined(HAVE_ANDROID_OS)
994    CHECK_EQ((int)mAuthType, (int)DIGEST);
995
996    AString method, url;
997    GetMethodAndURL(*request, &method, &url);
998
999    AString A1;
1000    A1.append(mUser);
1001    A1.append(":");
1002    A1.append("Streaming Server");
1003    A1.append(":");
1004    A1.append(mPass);
1005
1006    AString A2;
1007    A2.append(method);
1008    A2.append(":");
1009    A2.append(url);
1010
1011    AString HA1, HA2;
1012    H(A1, &HA1);
1013    H(A2, &HA2);
1014
1015    AString tmp;
1016    tmp.append(HA1);
1017    tmp.append(":");
1018    tmp.append(mNonce);
1019    tmp.append(":");
1020    tmp.append(HA2);
1021
1022    AString digest;
1023    H(tmp, &digest);
1024
1025    AString fragment;
1026    fragment.append("Authorization: Digest ");
1027    fragment.append("nonce=\"");
1028    fragment.append(mNonce);
1029    fragment.append("\", ");
1030    fragment.append("username=\"");
1031    fragment.append(mUser);
1032    fragment.append("\", ");
1033    fragment.append("uri=\"");
1034    fragment.append(url);
1035    fragment.append("\", ");
1036    fragment.append("response=\"");
1037    fragment.append(digest);
1038    fragment.append("\"");
1039    fragment.append("\r\n");
1040
1041    request->insert(fragment, i + 2);
1042#endif
1043}
1044
1045void ARTSPConnection::addUserAgent(AString *request) const {
1046    // Find the boundary between headers and the body.
1047    ssize_t i = request->find("\r\n\r\n");
1048    CHECK_GE(i, 0);
1049
1050    request->insert(sUserAgent, i + 2);
1051}
1052
1053}  // namespace android
1054