1/*
2 * Copyright (c) 2008-2009, Motorola, Inc.
3 *
4 * All rights reserved.
5 *
6 * Redistribution and use in source and binary forms, with or without
7 * modification, are permitted provided that the following conditions are met:
8 *
9 * - Redistributions of source code must retain the above copyright notice,
10 * this list of conditions and the following disclaimer.
11 *
12 * - Redistributions in binary form must reproduce the above copyright notice,
13 * this list of conditions and the following disclaimer in the documentation
14 * and/or other materials provided with the distribution.
15 *
16 * - Neither the name of the Motorola, Inc. nor the names of its contributors
17 * may be used to endorse or promote products derived from this software
18 * without specific prior written permission.
19 *
20 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
21 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
22 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
23 * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
24 * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
25 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
26 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
27 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
28 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
29 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
30 * POSSIBILITY OF SUCH DAMAGE.
31 */
32
33package com.android.bluetooth.opp;
34
35import java.io.BufferedOutputStream;
36import java.io.File;
37import java.io.IOException;
38import java.io.InputStream;
39import java.util.Arrays;
40
41import android.content.ContentValues;
42import android.content.Context;
43import android.content.Intent;
44import android.net.Uri;
45import android.os.Handler;
46import android.os.Message;
47import android.os.PowerManager;
48import android.os.PowerManager.WakeLock;
49import android.util.Log;
50import android.webkit.MimeTypeMap;
51
52import javax.obex.HeaderSet;
53import javax.obex.ObexTransport;
54import javax.obex.Operation;
55import javax.obex.ResponseCodes;
56import javax.obex.ServerRequestHandler;
57import javax.obex.ServerSession;
58
59/**
60 * This class runs as an OBEX server
61 */
62public class BluetoothOppObexServerSession extends ServerRequestHandler implements
63        BluetoothOppObexSession {
64
65    private static final String TAG = "BtOppObexServer";
66    private static final boolean D = Constants.DEBUG;
67    private static final boolean V = Constants.VERBOSE;
68
69    private ObexTransport mTransport;
70
71    private Context mContext;
72
73    private Handler mCallback = null;
74
75    /* status when server is blocking for user/auto confirmation */
76    private boolean mServerBlocking = true;
77
78    /* the current transfer info */
79    private BluetoothOppShareInfo mInfo;
80
81    /* info id when we insert the record */
82    private int mLocalShareInfoId;
83
84    private int mAccepted = BluetoothShare.USER_CONFIRMATION_PENDING;
85
86    private boolean mInterrupted = false;
87
88    private ServerSession mSession;
89
90    private long mTimestamp;
91
92    private BluetoothOppReceiveFileInfo mFileInfo;
93
94    private WakeLock mWakeLock;
95
96    private WakeLock mPartialWakeLock;
97
98    boolean mTimeoutMsgSent = false;
99
100    public BluetoothOppObexServerSession(Context context, ObexTransport transport) {
101        mContext = context;
102        mTransport = transport;
103        PowerManager pm = (PowerManager)mContext.getSystemService(Context.POWER_SERVICE);
104        mWakeLock = pm.newWakeLock(PowerManager.FULL_WAKE_LOCK | PowerManager.ACQUIRE_CAUSES_WAKEUP
105                | PowerManager.ON_AFTER_RELEASE, TAG);
106        mPartialWakeLock = pm.newWakeLock(PowerManager.PARTIAL_WAKE_LOCK, TAG);
107    }
108
109    public void unblock() {
110        mServerBlocking = false;
111    }
112
113    /**
114     * Called when connection is accepted from remote, to retrieve the first
115     * Header then wait for user confirmation
116     */
117    public void preStart() {
118        if (D) Log.d(TAG, "acquire full WakeLock");
119        mWakeLock.acquire();
120        try {
121            if (D) Log.d(TAG, "Create ServerSession with transport " + mTransport.toString());
122            mSession = new ServerSession(mTransport, this, null);
123        } catch (IOException e) {
124            Log.e(TAG, "Create server session error" + e);
125        }
126    }
127
128    /**
129     * Called from BluetoothOppTransfer to start the "Transfer"
130     */
131    public void start(Handler handler) {
132        if (D) Log.d(TAG, "Start!");
133        mCallback = handler;
134
135    }
136
137    /**
138     * Called from BluetoothOppTransfer to cancel the "Transfer" Otherwise,
139     * server should end by itself.
140     */
141    public void stop() {
142        /*
143         * TODO now we implement in a tough way, just close the socket.
144         * maybe need nice way
145         */
146        if (D) Log.d(TAG, "Stop!");
147        mInterrupted = true;
148        if (mSession != null) {
149            try {
150                mSession.close();
151                mTransport.close();
152            } catch (IOException e) {
153                Log.e(TAG, "close mTransport error" + e);
154            }
155        }
156        mCallback = null;
157        mSession = null;
158    }
159
160    public void addShare(BluetoothOppShareInfo info) {
161        if (D) Log.d(TAG, "addShare for id " + info.mId);
162        mInfo = info;
163        mFileInfo = processShareInfo();
164    }
165
166    @Override
167    public int onPut(Operation op) {
168        if (D) Log.d(TAG, "onPut " + op.toString());
169        HeaderSet request;
170        String name, mimeType;
171        Long length;
172
173        int obexResponse = ResponseCodes.OBEX_HTTP_OK;
174
175        /**
176         * For multiple objects, reject further objects after user deny the
177         * first one
178         */
179        if (mAccepted == BluetoothShare.USER_CONFIRMATION_DENIED) {
180            return ResponseCodes.OBEX_HTTP_FORBIDDEN;
181        }
182
183        String destination;
184        if (mTransport instanceof BluetoothOppRfcommTransport) {
185            destination = ((BluetoothOppRfcommTransport)mTransport).getRemoteAddress();
186        } else {
187            destination = "FF:FF:FF:00:00:00";
188        }
189        boolean isWhitelisted = BluetoothOppManager.getInstance(mContext).
190                isWhitelisted(destination);
191
192        try {
193            boolean pre_reject = false;
194
195            request = op.getReceivedHeader();
196            if (V) Constants.logHeader(request);
197            name = (String)request.getHeader(HeaderSet.NAME);
198            length = (Long)request.getHeader(HeaderSet.LENGTH);
199            mimeType = (String)request.getHeader(HeaderSet.TYPE);
200
201            if (length == 0) {
202                if (D) Log.w(TAG, "length is 0, reject the transfer");
203                pre_reject = true;
204                obexResponse = ResponseCodes.OBEX_HTTP_LENGTH_REQUIRED;
205            }
206
207            if (name == null || name.equals("")) {
208                if (D) Log.w(TAG, "name is null or empty, reject the transfer");
209                pre_reject = true;
210                obexResponse = ResponseCodes.OBEX_HTTP_BAD_REQUEST;
211            }
212
213            if (!pre_reject) {
214                /* first we look for Mimetype in Android map */
215                String extension, type;
216                int dotIndex = name.lastIndexOf(".");
217                if (dotIndex < 0 && mimeType == null) {
218                    if (D) Log.w(TAG, "There is no file extension or mime type," +
219                            "reject the transfer");
220                    pre_reject = true;
221                    obexResponse = ResponseCodes.OBEX_HTTP_BAD_REQUEST;
222                } else {
223                    extension = name.substring(dotIndex + 1).toLowerCase();
224                    MimeTypeMap map = MimeTypeMap.getSingleton();
225                    type = map.getMimeTypeFromExtension(extension);
226                    if (V) Log.v(TAG, "Mimetype guessed from extension " + extension + " is " + type);
227                    if (type != null) {
228                        mimeType = type;
229
230                    } else {
231                        if (mimeType == null) {
232                            if (D) Log.w(TAG, "Can't get mimetype, reject the transfer");
233                            pre_reject = true;
234                            obexResponse = ResponseCodes.OBEX_HTTP_UNSUPPORTED_TYPE;
235                        }
236                    }
237                    if (mimeType != null) {
238                        mimeType = mimeType.toLowerCase();
239                    }
240                }
241            }
242
243            // Reject policy: anything outside the "white list" plus unspecified
244            // MIME Types. Also reject everything in the "black list".
245            if (!pre_reject
246                    && (mimeType == null
247                            || (!isWhitelisted && !Constants.mimeTypeMatches(mimeType,
248                                    Constants.ACCEPTABLE_SHARE_INBOUND_TYPES))
249                            || Constants.mimeTypeMatches(mimeType,
250                                    Constants.UNACCEPTABLE_SHARE_INBOUND_TYPES))) {
251                if (D) Log.w(TAG, "mimeType is null or in unacceptable list, reject the transfer");
252                pre_reject = true;
253                obexResponse = ResponseCodes.OBEX_HTTP_UNSUPPORTED_TYPE;
254            }
255
256            if (pre_reject && obexResponse != ResponseCodes.OBEX_HTTP_OK) {
257                // some bad implemented client won't send disconnect
258                return obexResponse;
259            }
260
261        } catch (IOException e) {
262            Log.e(TAG, "get getReceivedHeaders error " + e);
263            return ResponseCodes.OBEX_HTTP_BAD_REQUEST;
264        }
265
266        ContentValues values = new ContentValues();
267
268        values.put(BluetoothShare.FILENAME_HINT, name);
269        values.put(BluetoothShare.TOTAL_BYTES, length.intValue());
270        values.put(BluetoothShare.MIMETYPE, mimeType);
271
272        values.put(BluetoothShare.DESTINATION, destination);
273
274        values.put(BluetoothShare.DIRECTION, BluetoothShare.DIRECTION_INBOUND);
275        values.put(BluetoothShare.TIMESTAMP, mTimestamp);
276
277        boolean needConfirm = true;
278        /** It's not first put if !serverBlocking, so we auto accept it */
279        if (!mServerBlocking) {
280            values.put(BluetoothShare.USER_CONFIRMATION,
281                    BluetoothShare.USER_CONFIRMATION_AUTO_CONFIRMED);
282            needConfirm = false;
283        }
284
285        if (isWhitelisted) {
286            values.put(BluetoothShare.USER_CONFIRMATION,
287                    BluetoothShare.USER_CONFIRMATION_HANDOVER_CONFIRMED);
288            needConfirm = false;
289        }
290
291        Uri contentUri = mContext.getContentResolver().insert(BluetoothShare.CONTENT_URI, values);
292        mLocalShareInfoId = Integer.parseInt(contentUri.getPathSegments().get(1));
293
294        if (needConfirm) {
295            Intent in = new Intent(BluetoothShare.INCOMING_FILE_CONFIRMATION_REQUEST_ACTION);
296            in.setClassName(Constants.THIS_PACKAGE_NAME, BluetoothOppReceiver.class.getName());
297            mContext.sendBroadcast(in);
298        }
299
300        if (V) Log.v(TAG, "insert contentUri: " + contentUri);
301        if (V) Log.v(TAG, "mLocalShareInfoId = " + mLocalShareInfoId);
302
303        if (V) Log.v(TAG, "acquire partial WakeLock");
304
305
306        synchronized (this) {
307            if (mWakeLock.isHeld()) {
308                mPartialWakeLock.acquire();
309                mWakeLock.release();
310            }
311            mServerBlocking = true;
312            try {
313
314                while (mServerBlocking) {
315                    wait(1000);
316                    if (mCallback != null && !mTimeoutMsgSent) {
317                        mCallback.sendMessageDelayed(mCallback
318                                .obtainMessage(BluetoothOppObexSession.MSG_CONNECT_TIMEOUT),
319                                BluetoothOppObexSession.SESSION_TIMEOUT);
320                        mTimeoutMsgSent = true;
321                        if (V) Log.v(TAG, "MSG_CONNECT_TIMEOUT sent");
322                    }
323                }
324            } catch (InterruptedException e) {
325                if (V) Log.v(TAG, "Interrupted in onPut blocking");
326            }
327        }
328        if (D) Log.d(TAG, "Server unblocked ");
329        synchronized (this) {
330            if (mCallback != null && mTimeoutMsgSent) {
331                mCallback.removeMessages(BluetoothOppObexSession.MSG_CONNECT_TIMEOUT);
332            }
333        }
334
335        /* we should have mInfo now */
336
337        /*
338         * TODO check if this mInfo match the one that we insert before server
339         * blocking? just to make sure no error happens
340         */
341        if (mInfo.mId != mLocalShareInfoId) {
342            Log.e(TAG, "Unexpected error!");
343        }
344        mAccepted = mInfo.mConfirm;
345
346        if (V) Log.v(TAG, "after confirm: userAccepted=" + mAccepted);
347        int status = BluetoothShare.STATUS_SUCCESS;
348
349        if (mAccepted == BluetoothShare.USER_CONFIRMATION_CONFIRMED
350                || mAccepted == BluetoothShare.USER_CONFIRMATION_AUTO_CONFIRMED
351                || mAccepted == BluetoothShare.USER_CONFIRMATION_HANDOVER_CONFIRMED) {
352            /* Confirm or auto-confirm */
353
354            if (mFileInfo.mFileName == null) {
355                status = mFileInfo.mStatus;
356                /* TODO need to check if this line is correct */
357                mInfo.mStatus = mFileInfo.mStatus;
358                Constants.updateShareStatus(mContext, mInfo.mId, status);
359                obexResponse = ResponseCodes.OBEX_HTTP_INTERNAL_ERROR;
360
361            }
362
363            if (mFileInfo.mFileName != null) {
364
365                ContentValues updateValues = new ContentValues();
366                contentUri = Uri.parse(BluetoothShare.CONTENT_URI + "/" + mInfo.mId);
367                updateValues.put(BluetoothShare._DATA, mFileInfo.mFileName);
368                updateValues.put(BluetoothShare.STATUS, BluetoothShare.STATUS_RUNNING);
369                mContext.getContentResolver().update(contentUri, updateValues, null, null);
370
371                status = receiveFile(mFileInfo, op);
372                /*
373                 * TODO map status to obex response code
374                 */
375                if (status != BluetoothShare.STATUS_SUCCESS) {
376                    obexResponse = ResponseCodes.OBEX_HTTP_INTERNAL_ERROR;
377                }
378                Constants.updateShareStatus(mContext, mInfo.mId, status);
379            }
380
381            if (status == BluetoothShare.STATUS_SUCCESS) {
382                Message msg = Message.obtain(mCallback, BluetoothOppObexSession.MSG_SHARE_COMPLETE);
383                msg.obj = mInfo;
384                msg.sendToTarget();
385            } else {
386                if (mCallback != null) {
387                    Message msg = Message.obtain(mCallback,
388                            BluetoothOppObexSession.MSG_SESSION_ERROR);
389                    mInfo.mStatus = status;
390                    msg.obj = mInfo;
391                    msg.sendToTarget();
392                }
393            }
394        } else if (mAccepted == BluetoothShare.USER_CONFIRMATION_DENIED
395                || mAccepted == BluetoothShare.USER_CONFIRMATION_TIMEOUT) {
396            /* user actively deny the inbound transfer */
397            /*
398             * Note There is a question: what's next if user deny the first obj?
399             * Option 1 :continue prompt for next objects
400             * Option 2 :reject next objects and finish the session
401             * Now we take option 2:
402             */
403
404            Log.i(TAG, "Rejected incoming request");
405            if (mFileInfo.mFileName != null) {
406                try {
407                    mFileInfo.mOutputStream.close();
408                } catch (IOException e) {
409                    Log.e(TAG, "error close file stream");
410                }
411                new File(mFileInfo.mFileName).delete();
412            }
413            // set status as local cancel
414            status = BluetoothShare.STATUS_CANCELED;
415            Constants.updateShareStatus(mContext, mInfo.mId, status);
416            obexResponse = ResponseCodes.OBEX_HTTP_FORBIDDEN;
417
418            Message msg = Message.obtain(mCallback);
419            msg.what = BluetoothOppObexSession.MSG_SHARE_INTERRUPTED;
420            mInfo.mStatus = status;
421            msg.obj = mInfo;
422            msg.sendToTarget();
423        }
424        return obexResponse;
425    }
426
427    private int receiveFile(BluetoothOppReceiveFileInfo fileInfo, Operation op) {
428        /*
429         * implement receive file
430         */
431        int status = -1;
432        BufferedOutputStream bos = null;
433
434        InputStream is = null;
435        boolean error = false;
436        try {
437            is = op.openInputStream();
438        } catch (IOException e1) {
439            Log.e(TAG, "Error when openInputStream");
440            status = BluetoothShare.STATUS_OBEX_DATA_ERROR;
441            error = true;
442        }
443
444        Uri contentUri = Uri.parse(BluetoothShare.CONTENT_URI + "/" + mInfo.mId);
445
446        if (!error) {
447            ContentValues updateValues = new ContentValues();
448            updateValues.put(BluetoothShare._DATA, fileInfo.mFileName);
449            mContext.getContentResolver().update(contentUri, updateValues, null, null);
450        }
451
452        int position = 0;
453        if (!error) {
454            bos = new BufferedOutputStream(fileInfo.mOutputStream, 0x10000);
455        }
456
457        if (!error) {
458            int outputBufferSize = op.getMaxPacketSize();
459            byte[] b = new byte[outputBufferSize];
460            int readLength = 0;
461            long timestamp = 0;
462            try {
463                while ((!mInterrupted) && (position != fileInfo.mLength)) {
464
465                    if (V) timestamp = System.currentTimeMillis();
466
467                    readLength = is.read(b);
468
469                    if (readLength == -1) {
470                        if (D) Log.d(TAG, "Receive file reached stream end at position" + position);
471                        break;
472                    }
473
474                    bos.write(b, 0, readLength);
475                    position += readLength;
476
477                    if (V) {
478                        Log.v(TAG, "Receive file position = " + position + " readLength "
479                                + readLength + " bytes took "
480                                + (System.currentTimeMillis() - timestamp) + " ms");
481                    }
482
483                    ContentValues updateValues = new ContentValues();
484                    updateValues.put(BluetoothShare.CURRENT_BYTES, position);
485                    mContext.getContentResolver().update(contentUri, updateValues, null, null);
486                }
487            } catch (IOException e1) {
488                Log.e(TAG, "Error when receiving file");
489                /* OBEX Abort packet received from remote device */
490                if ("Abort Received".equals(e1.getMessage())) {
491                    status = BluetoothShare.STATUS_CANCELED;
492                } else {
493                    status = BluetoothShare.STATUS_OBEX_DATA_ERROR;
494                }
495                error = true;
496            }
497        }
498
499        if (mInterrupted) {
500            if (D) Log.d(TAG, "receiving file interrupted by user.");
501            status = BluetoothShare.STATUS_CANCELED;
502        } else {
503            if (position == fileInfo.mLength) {
504                if (D) Log.d(TAG, "Receiving file completed for " + fileInfo.mFileName);
505                status = BluetoothShare.STATUS_SUCCESS;
506            } else {
507                if (D) Log.d(TAG, "Reading file failed at " + position + " of " + fileInfo.mLength);
508                if (status == -1) {
509                    status = BluetoothShare.STATUS_UNKNOWN_ERROR;
510                }
511            }
512        }
513
514        if (bos != null) {
515            try {
516                bos.close();
517            } catch (IOException e) {
518                Log.e(TAG, "Error when closing stream after send");
519            }
520        }
521        return status;
522    }
523
524    private BluetoothOppReceiveFileInfo processShareInfo() {
525        if (D) Log.d(TAG, "processShareInfo() " + mInfo.mId);
526        BluetoothOppReceiveFileInfo fileInfo = BluetoothOppReceiveFileInfo.generateFileInfo(
527                mContext, mInfo.mId);
528        if (V) {
529            Log.v(TAG, "Generate BluetoothOppReceiveFileInfo:");
530            Log.v(TAG, "filename  :" + fileInfo.mFileName);
531            Log.v(TAG, "length    :" + fileInfo.mLength);
532            Log.v(TAG, "status    :" + fileInfo.mStatus);
533        }
534        return fileInfo;
535    }
536
537    @Override
538    public int onConnect(HeaderSet request, HeaderSet reply) {
539
540        if (D) Log.d(TAG, "onConnect");
541        if (V) Constants.logHeader(request);
542        try {
543            byte[] uuid = (byte[])request.getHeader(HeaderSet.TARGET);
544            if (V) Log.v(TAG, "onConnect(): uuid =" + Arrays.toString(uuid));
545            if(uuid != null) {
546                 return ResponseCodes.OBEX_HTTP_NOT_ACCEPTABLE;
547            }
548        } catch (IOException e) {
549            Log.e(TAG, e.toString());
550            return ResponseCodes.OBEX_HTTP_INTERNAL_ERROR;
551        }
552        mTimestamp = System.currentTimeMillis();
553        return ResponseCodes.OBEX_HTTP_OK;
554    }
555
556    @Override
557    public void onDisconnect(HeaderSet req, HeaderSet resp) {
558        if (D) Log.d(TAG, "onDisconnect");
559        resp.responseCode = ResponseCodes.OBEX_HTTP_OK;
560    }
561
562    private synchronized void releaseWakeLocks() {
563        if (mWakeLock.isHeld()) {
564            mWakeLock.release();
565        }
566        if (mPartialWakeLock.isHeld()) {
567            mPartialWakeLock.release();
568        }
569    }
570
571    @Override
572    public void onClose() {
573        if (V) Log.v(TAG, "release WakeLock");
574        releaseWakeLocks();
575
576        /* onClose could happen even before start() where mCallback is set */
577        if (mCallback != null) {
578            Message msg = Message.obtain(mCallback);
579            msg.what = BluetoothOppObexSession.MSG_SESSION_COMPLETE;
580            msg.obj = mInfo;
581            msg.sendToTarget();
582        }
583    }
584}
585