obexwebrequest.cs

蓝牙传输控件,用于蓝牙文件上传和下载。芯片只要选用crs

				}
				else
				{
					totalBytes = requestBuffer.Length;
				}

                bluetoothX.TotalLen = totalBytes;

				MemoryStream readBuffer = new MemoryStream(requestBuffer);

				while (totalBytes > 0)
				{
					if(totalBytes <= (remoteMaxPacket - 6))
					{
						thisRequest = totalBytes;

						totalBytes = 0;
						buffer[0] = (byte)ObexMethod.PutFinal;
						buffer[3] = (byte)ObexHeader.EndOfBody;

					}
					else
					{
						thisRequest = remoteMaxPacket - 6;
						//decrement byte count
						totalBytes -= thisRequest;
						buffer[0] = (byte)ObexMethod.Put;
						buffer[3] = (byte)ObexHeader.Body;
					}

					int readBytes = readBuffer.Read(buffer, 6, thisRequest);
					
					BitConverter.GetBytes(IPAddress.HostToNetworkOrder((short)(readBytes+3))).CopyTo(buffer, 4);
			
					BitConverter.GetBytes(IPAddress.HostToNetworkOrder((short)(readBytes + 6))).CopyTo(buffer, 1);
					
                    ns.Write(buffer, 0, readBytes + 6);

                    bluetoothX.CurrentPutted = totalBytes;

					if (!CheckResponse(ref status))
					{
						return status;
					}
				}
			}

			return status;

		}
		#endregion

		#region DoGet
		private void DoGet(MemoryStream ms, WebHeaderCollection headers)
		{
			byte[] buffer = new byte[remoteMaxPacket];

			buffer[0] = (byte)ObexMethod.Get;
			int bufferlen = 3;

			if(connectionId != 0)
			{
				buffer[bufferlen] = (byte)ObexHeader.ConnectionID;
				int typeheaderlen = IPAddress.HostToNetworkOrder((short)5);
				BitConverter.GetBytes(connectionId).CopyTo(buffer, bufferlen+1);
				
				bufferlen += 5;
			}

			string type = this.headers["TYPE"];
			if (type != null)
			{
				buffer[bufferlen] = (byte)ObexHeader.Type;
				int typeheaderlen = IPAddress.HostToNetworkOrder((short)((type.Length + 1) + 3));
				BitConverter.GetBytes(typeheaderlen).CopyTo(buffer, bufferlen+1);
				System.Text.Encoding.ASCII.GetBytes(type).CopyTo(buffer, bufferlen+3);

				bufferlen += type.Length+4;
			}
			
			string filename = uri.PathAndQuery.TrimStart(new char[]{'/'});
			if(filename.Length>0)
			{
				int filenameLength = (filename.Length + 1) * 2;
				buffer[bufferlen] = (byte)ObexHeader.Name;
				int filenameheaderlen = IPAddress.HostToNetworkOrder((short)(filenameLength + 3));
				BitConverter.GetBytes(filenameheaderlen).CopyTo(buffer, bufferlen+1);
				System.Text.Encoding.BigEndianUnicode.GetBytes(filename).CopyTo(buffer, bufferlen+3);

				bufferlen += filenameLength+3;
			}

			BitConverter.GetBytes(IPAddress.HostToNetworkOrder((short)bufferlen)).CopyTo(buffer, 1);

			ns.Write(buffer, 0, bufferlen);

			int bytesread = ns.Read(buffer, 0, 3);

            if ((bytesread > 0) && ((ObexStatusCode)buffer[0] & ObexStatusCode.OK) == ObexStatusCode.OK)
			{
				//get length
				short len = (short)IPAddress.NetworkToHostOrder(BitConverter.ToInt16(buffer, 1));

				while (bytesread > len)
				{
					bytesread += ns.Read(buffer, bytesread, len-bytesread);

                    ParseHeaders(buffer, ref remoteMaxPacket, ms, headers);
				}

			}
			else
			{
				throw new ProtocolViolationException("Invalid response received: " + ((ObexStatusCode)buffer[0]).ToString());
			}
			
		}
		#endregion

		#region Check Response
		private bool CheckResponse(ref ObexStatusCode status)
		{
			byte[] receiveBuffer = new byte[3];
            ns.Read(receiveBuffer, 0, receiveBuffer.Length);

			status = (ObexStatusCode)receiveBuffer[0];

			switch(status)
			{
                case ObexStatusCode.Final | ObexStatusCode.OK:
                case ObexStatusCode.OK:
				case ObexStatusCode.Final | ObexStatusCode.Continue:
				case ObexStatusCode.Continue:
					//get length
					short len = (short)(IPAddress.NetworkToHostOrder(BitConverter.ToInt16(receiveBuffer, 1)) - 3);

					if (len > 0)
					{
						byte[] receivePacket2 = new byte[len];
                        ns.Read(receivePacket2, 0, len);

						remoteMaxPacket = IPAddress.NetworkToHostOrder(BitConverter.ToInt16(receivePacket2, 2));
					}

					return true;
				default:
					return false;
			}
		}
		#endregion

		#region Disconnect
		private void Disconnect()
		{
            if (ns != null)
            {
                ObexStatusCode status = 0;

                short disconnectPacketSize = 3;
                byte[] disconnectPacket = new byte[8];
                disconnectPacket[0] = (byte)ObexMethod.Disconnect;

                //add connectionid header
                if (connectionId != 0)
                {
                    disconnectPacket[3] = (byte)ObexHeader.ConnectionID;
                    BitConverter.GetBytes(IPAddress.HostToNetworkOrder(connectionId)).CopyTo(disconnectPacket, 4);
                    disconnectPacketSize += 5;
                }

                //set packet size
                BitConverter.GetBytes(IPAddress.HostToNetworkOrder(disconnectPacketSize)).CopyTo(disconnectPacket, 1);

                ns.Write(disconnectPacket, 0, disconnectPacketSize);

                CheckResponse(ref status);

                ns.Close();
            }
		}
		#endregion

		#region Get Request Stream
		public override System.IO.Stream GetRequestStream()
		{
			return requestStream;
		}
		#endregion

		#region Read File
		public void ReadFile(string fileName)
		{
			FileStream fs = File.OpenRead(fileName);
			long len = 0;
			//read in 1k chunks
			byte[] buffer = new byte[1024];
			int readBytes;
			do
			{
				readBytes = fs.Read(buffer, 0, buffer.Length);
				len += readBytes;
				requestStream.Write(buffer, 0, readBytes);
			}while (readBytes > 0);

			fs.Close();
			requestStream.Close();

			//write content length
			this.ContentLength = len;
		}
		#endregion

		#region Get Response
		public override WebResponse GetResponse()
		{
			ObexStatusCode status;
			MemoryStream ms = new MemoryStream();
			WebHeaderCollection responseHeaders = new WebHeaderCollection();
			//try connecting if not already
			try
			{
				status = Connect();
			}
			catch
			{
				//handle connection failure gracefully
				return new ObexWebResponse(null,responseHeaders, ObexStatusCode.BadRequest);
			}

            try
            {
                if (this.method == ObexMethod.Get)
                {
                    DoGet(ms, responseHeaders );
                    ms.Seek(0, SeekOrigin.Begin);
                }
                else
                {
                    status = DoPut();
                }
            }
            catch
            {
                return new ObexWebResponse(null, responseHeaders, ObexStatusCode.InternalServerError);
            }
            finally
            {
                Disconnect();
            }

			return new ObexWebResponse(ms, responseHeaders, status);
		}
		#endregion


        internal static void ParseHeaders(byte[] packet, ref short remoteMaxPacket, Stream bodyStream, WebHeaderCollection headers)
        {
            ObexMethod method = (ObexMethod)packet[0];

            int pos = 0;

            while (pos < packet.Length)
            {
                ObexHeader header = (ObexHeader)packet[pos];
                switch (header)
                {
                    case ObexHeader.None:
                        return;
                    case (ObexHeader)0x10:
                        remoteMaxPacket = IPAddress.NetworkToHostOrder(BitConverter.ToInt16(packet, pos + 2));
                        pos += 4;
                        break;

                    case ObexHeader.ConnectionID:
                    case ObexHeader.Count:
                    case ObexHeader.Length:
                    case ObexHeader.CreatorID:
                    case ObexHeader.Time4Byte:
                        int intValue = IPAddress.NetworkToHostOrder(BitConverter.ToInt32(packet, pos + 1));
                        headers.Add(header.ToString().ToUpper(), intValue.ToString());
                        pos += 5;
                        break;

                    case ObexHeader.Who:
                        short whoSize = IPAddress.NetworkToHostOrder(BitConverter.ToInt16(packet, pos + 1));
                        byte[] whoBytes = new byte[16];
                        Buffer.BlockCopy(packet, pos + 3, whoBytes, 0, whoSize - 3);
                        Guid service = new Guid(whoBytes);
                        headers.Add(header.ToString().ToUpper(), service.ToString());
                        pos += whoSize;
                        break;

                    case ObexHeader.Body:
                    case ObexHeader.EndOfBody:
                        short bodySize = IPAddress.NetworkToHostOrder(BitConverter.ToInt16(packet, pos + 1));
                        bodyStream.Write(packet, pos + 3, bodySize - 3);
                        pos += bodySize;
                        break;

                    default:
                        int headerSize = IPAddress.NetworkToHostOrder(BitConverter.ToInt16(packet, pos + 1));

                        if (headerSize > 3)
                        {
                            string headerString = System.Text.Encoding.BigEndianUnicode.GetString(packet, pos + 3, headerSize - 4);
                            if (headerString != null)
                            {
                                int nullindex = headerString.IndexOf('\0');
                                if (nullindex > -1)
                                {
                                    headerString = headerString.Substring(0, nullindex);
                                }

                                if (headerString != string.Empty)
                                {
                                    headers.Add(header.ToString().ToUpper(), headerString);
                                }
                            }
                        }

                        pos += headerSize;
                        break;
                }


            }
        }
	}
}