2008-03-07 Tatsuhiro Tsujikawa <tujikawa at rednoah dot com>

	Use unsigned char for data store.

55 files changed, 225 insertions, 187 deletions

diff --git a/src/BtAnnounce.h b/src/BtAnnounce.h
index 8a9f647f..6efe9683 100644
--- a/src/BtAnnounce.h
+++ b/src/BtAnnounce.h
@@ -91,7 +91,7 @@ public:
   /**
    * Processes the repsponse from the tracker.
    */
-  virtual void processAnnounceResponse(const char* trackerResponse,
+  virtual void processAnnounceResponse(const unsigned char* trackerResponse,
 				       size_t trackerResponseLength) = 0;
 
   /**
diff --git a/src/BtDependency.cc b/src/BtDependency.cc
index 63728a6e..8b7d1a93 100644
--- a/src/BtDependency.cc
+++ b/src/BtDependency.cc
@@ -69,7 +69,7 @@ bool BtDependency::resolve()
       DiskAdaptorHandle diskAdaptor = dependee->getPieceStorage()->getDiskAdaptor();
       diskAdaptor->openExistingFile();
       std::string content = Util::toString(diskAdaptor);
-      btContext->loadFromMemory(content.c_str(), content.size(),
+      btContext->loadFromMemory(content,
 				File(dependee->getFilePath()).getBasename());
       if(_option->defined(PREF_PEER_ID_PREFIX)) {
 	btContext->setPeerIdPrefix(_option->get(PREF_PEER_ID_PREFIX));
diff --git a/src/BtExtendedMessage.cc b/src/BtExtendedMessage.cc
index b138d667..a53a3f06 100644
--- a/src/BtExtendedMessage.cc
+++ b/src/BtExtendedMessage.cc
@@ -97,12 +97,12 @@ std::string BtExtendedMessage::toString() const {
 BtExtendedMessageHandle
 BtExtendedMessage::create(const BtContextHandle& btContext,
 			  const PeerHandle& peer,
-			  const char* data, size_t dataLength)
+			  const unsigned char* data, size_t dataLength)
 {
   if(dataLength < 2) {
     throw new DlAbortEx(MSG_TOO_SMALL_PAYLOAD_SIZE, "extended", dataLength);
   }
-  int8_t id = PeerMessageUtil::getId((const unsigned char*)data);
+  int8_t id = PeerMessageUtil::getId(data);
   if(id != ID) {
     throw new DlAbortEx(EX_INVALID_BT_MESSAGE_ID, id, "extended", ID);
   }
diff --git a/src/BtExtendedMessage.h b/src/BtExtendedMessage.h
index 12a16fe4..18ad3e28 100644
--- a/src/BtExtendedMessage.h
+++ b/src/BtExtendedMessage.h
@@ -60,7 +60,7 @@ public:
 
   static BtExtendedMessageHandle create(const SharedHandle<BtContext>& btContext,
 					const SharedHandle<Peer>& peer,
-					const char* data,
+					const unsigned char* data,
 					size_t dataLength);
 
   virtual int8_t getId() { return ID; }
diff --git a/src/BtPostDownloadHandler.cc b/src/BtPostDownloadHandler.cc
index 22e77dd3..4ea179ce 100644
--- a/src/BtPostDownloadHandler.cc
+++ b/src/BtPostDownloadHandler.cc
@@ -73,8 +73,7 @@ RequestGroups BtPostDownloadHandler::getNextRequestGroups(RequestGroup* requestG
     throw;
   }
   DefaultBtContextHandle btContext = new DefaultBtContext();
-  btContext->loadFromMemory(content.c_str(), content.size(),
-			    File(requestGroup->getFilePath()).getBasename());
+  btContext->loadFromMemory(content, File(requestGroup->getFilePath()).getBasename());
   if(op->defined(PREF_PEER_ID_PREFIX)) {
     btContext->setPeerIdPrefix(op->get(PREF_PEER_ID_PREFIX));
   }
diff --git a/src/ChunkedEncoding.cc b/src/ChunkedEncoding.cc
index 7840c8d6..27b69c73 100644
--- a/src/ChunkedEncoding.cc
+++ b/src/ChunkedEncoding.cc
@@ -44,7 +44,7 @@ namespace aria2 {
 
 ChunkedEncoding::ChunkedEncoding() {
   strbufSize = 4096;
-  strbuf = new char[strbufSize];
+  strbuf = new unsigned char[strbufSize];
   strbufTail = strbuf;
   state = READ_SIZE;
   chunkSize = 0;
@@ -63,9 +63,10 @@ bool ChunkedEncoding::finished() {
 
 void ChunkedEncoding::end() {}
 
-void ChunkedEncoding::inflate(char* outbuf, int32_t& outlen, const char* inbuf, int32_t inlen) {
+void ChunkedEncoding::inflate(unsigned char* outbuf, int32_t& outlen,
+			      const unsigned char* inbuf, int32_t inlen) {
   addBuffer(inbuf, inlen);
-  char* p = strbuf;
+  unsigned char* p = strbuf;
   int32_t clen = 0;
   while(1) {
     if(state == READ_SIZE) {
@@ -98,7 +99,7 @@ void ChunkedEncoding::inflate(char* outbuf, int32_t& outlen, const char* inbuf,
   } else {
     // copy string between [p, strbufTail]
     int32_t unreadSize = strbufTail-p;
-    char* temp = new char[strbufSize];
+    unsigned char* temp = new unsigned char[strbufSize];
     memcpy(temp, p, unreadSize);
     delete [] strbuf;
     strbuf = temp;
@@ -107,7 +108,10 @@ void ChunkedEncoding::inflate(char* outbuf, int32_t& outlen, const char* inbuf,
   outlen = clen;
 }
 
-int32_t ChunkedEncoding::readData(char** pp, char* buf, int32_t& len, int32_t maxlen) {
+int32_t ChunkedEncoding::readData(unsigned char** pp,
+				  unsigned char* buf, int32_t& len,
+				  int32_t maxlen)
+{
   if(buf+len == buf+maxlen) {
     return -1;
   }
@@ -131,9 +135,9 @@ int32_t ChunkedEncoding::readData(char** pp, char* buf, int32_t& len, int32_t ma
   }
 }
 
-int32_t ChunkedEncoding::readDataEOL(char** pp) {
-  char* np = (char*)memchr(*pp, '\n', strbufTail-*pp);
-  char* rp = (char*)memchr(*pp, '\r', strbufTail-*pp);
+int32_t ChunkedEncoding::readDataEOL(unsigned char** pp) {
+  unsigned char* np = reinterpret_cast<unsigned char*>(memchr(*pp, '\n', strbufTail-*pp));
+  unsigned char* rp = reinterpret_cast<unsigned char*>(memchr(*pp, '\r', strbufTail-*pp));
   if(np != NULL && rp != NULL && np-rp == 1 && *pp == rp) {
     *pp += 2;
     return 0;
@@ -144,18 +148,18 @@ int32_t ChunkedEncoding::readDataEOL(char** pp) {
   }  
 }
 
-int32_t ChunkedEncoding::readChunkSize(char** pp) {
+int32_t ChunkedEncoding::readChunkSize(unsigned char** pp) {
   // we read chunk-size from *pp
-  char* p;
-  char* np = (char*)memchr(*pp, '\n', strbufTail-*pp);
-  char* rp = (char*)memchr(*pp, '\r', strbufTail-*pp);
+  unsigned char* p;
+  unsigned char* np = reinterpret_cast<unsigned char*>(memchr(*pp, '\n', strbufTail-*pp));
+  unsigned char* rp = reinterpret_cast<unsigned char*>(memchr(*pp, '\r', strbufTail-*pp));
   if(np == NULL || rp == NULL ||  np-rp != 1) {
     // \r\n is not found. Return -1
     return -1;
   }
   p = rp;
   // We ignore chunk-extension
-  char* exsp = (char*)memchr(*pp, ';', strbufTail-*pp);
+  unsigned char* exsp = reinterpret_cast<unsigned char*>(memchr(*pp, ';', strbufTail-*pp));
   if(exsp == 0 || p < exsp) {
     exsp = p;
   }
@@ -168,14 +172,14 @@ int32_t ChunkedEncoding::readChunkSize(char** pp) {
   return 0;
 }
 
-void ChunkedEncoding::addBuffer(const char* inbuf, int32_t inlen) {
+void ChunkedEncoding::addBuffer(const unsigned char* inbuf, int32_t inlen) {
   int32_t realbufSize = strbufTail-strbuf;
   if(realbufSize+inlen >= strbufSize) {
     if(realbufSize+inlen > MAX_BUFSIZE) {
       throw new DlAbortEx(EX_TOO_LARGE_CHUNK, realbufSize+inlen);
     }
     strbufSize = realbufSize+inlen;
-    char* temp = new char[strbufSize];
+    unsigned char* temp = new unsigned char[strbufSize];
     memcpy(temp, strbuf, realbufSize);
     delete [] strbuf;
     strbuf = temp;
diff --git a/src/ChunkedEncoding.h b/src/ChunkedEncoding.h
index eaaf2352..816376ad 100644
--- a/src/ChunkedEncoding.h
+++ b/src/ChunkedEncoding.h
@@ -48,18 +48,19 @@ private:
   };
   int32_t chunkSize;
   int32_t state;
-  char* strbuf;
+  unsigned char* strbuf;
   int32_t strbufSize;
-  char* strbufTail;
+  unsigned char* strbufTail;
 
   /**
    * Returns 0 if the size of chunk is retrieved successfully,
    * otherwise returns non-zero value.
    */
-  int32_t readChunkSize(char** pp);
-  int32_t readData(char** pp, char* buf, int32_t& len, int32_t maxlen);
-  void addBuffer(const char* inbuf, int32_t inlen);
-  int32_t readDataEOL(char** pp);
+  int32_t readChunkSize(unsigned char** pp);
+  int32_t readData(unsigned char** pp, unsigned char* buf, int32_t& len,
+		   int32_t maxlen);
+  void addBuffer(const unsigned char* inbuf, int32_t inlen);
+  int32_t readDataEOL(unsigned char** pp);
 
 
 public:
@@ -67,7 +68,8 @@ public:
   ~ChunkedEncoding();
 
   void init();
-  void inflate(char* outbuf, int32_t& outlen, const char* inbuf, int32_t inlen);
+  void inflate(unsigned char* outbuf, int32_t& outlen,
+	       const unsigned char* inbuf, int32_t inlen);
   bool finished();
   void end();
 };
diff --git a/src/DHTAbstractMessage.cc b/src/DHTAbstractMessage.cc
index b068e696..61f3c5b9 100644
--- a/src/DHTAbstractMessage.cc
+++ b/src/DHTAbstractMessage.cc
@@ -66,7 +66,7 @@ std::string DHTAbstractMessage::getBencodedMessage()
 void DHTAbstractMessage::send()
 {
   std::string message = getBencodedMessage();
-  _connection->sendMessage(message.c_str(),
+  _connection->sendMessage(reinterpret_cast<const unsigned char*>(message.c_str()),
 			   message.size(),
 			   _remoteNode->getIPAddress(),
 			   _remoteNode->getPort());
diff --git a/src/DHTConnection.h b/src/DHTConnection.h
index 9caf3124..c9773ab4 100644
--- a/src/DHTConnection.h
+++ b/src/DHTConnection.h
@@ -44,9 +44,9 @@ class DHTConnection {
 public:
   virtual ~DHTConnection() {}
 
-  virtual ssize_t receiveMessage(char* data, size_t len, std::string& host, uint16_t& port) = 0;
+  virtual ssize_t receiveMessage(unsigned char* data, size_t len, std::string& host, uint16_t& port) = 0;
 
-  virtual void sendMessage(const char* data, size_t len, const std::string& host, uint16_t port) = 0;
+  virtual void sendMessage(const unsigned char* data, size_t len, const std::string& host, uint16_t port) = 0;
 };
 
 } // namespace aria2
diff --git a/src/DHTConnectionImpl.cc b/src/DHTConnectionImpl.cc
index c7e54baf..d98ede59 100644
--- a/src/DHTConnectionImpl.cc
+++ b/src/DHTConnectionImpl.cc
@@ -73,7 +73,7 @@ uint16_t DHTConnectionImpl::bind(uint16_t port)
   return 0;
 }
 
-ssize_t DHTConnectionImpl::receiveMessage(char* data, size_t len, std::string& host, uint16_t& port)
+ssize_t DHTConnectionImpl::receiveMessage(unsigned char* data, size_t len, std::string& host, uint16_t& port)
 {
   if(_socket->isReadable(0)) {
     std::pair<std::string, uint16_t> remoteHost;
@@ -86,7 +86,7 @@ ssize_t DHTConnectionImpl::receiveMessage(char* data, size_t len, std::string& h
   }
 }
 
-void DHTConnectionImpl::sendMessage(const char* data, size_t len, const std::string& host, uint16_t port)
+void DHTConnectionImpl::sendMessage(const unsigned char* data, size_t len, const std::string& host, uint16_t port)
 {
   _socket->writeData(data, len, host, port);
 }
diff --git a/src/DHTConnectionImpl.h b/src/DHTConnectionImpl.h
index 96af0315..ecd484d6 100644
--- a/src/DHTConnectionImpl.h
+++ b/src/DHTConnectionImpl.h
@@ -58,9 +58,9 @@ public:
   
   uint16_t bind(uint16_t port);
 
-  virtual ssize_t receiveMessage(char* data, size_t len, std::string& host, uint16_t& port);
+  virtual ssize_t receiveMessage(unsigned char* data, size_t len, std::string& host, uint16_t& port);
 
-  virtual void sendMessage(const char* data, size_t len, const std::string& host, uint16_t port);
+  virtual void sendMessage(const unsigned char* data, size_t len, const std::string& host, uint16_t port);
 
   SharedHandle<SocketCore> getSocket() const;
 };
diff --git a/src/DHTFindNodeReplyMessage.cc b/src/DHTFindNodeReplyMessage.cc
index 8e5534ed..67570618 100644
--- a/src/DHTFindNodeReplyMessage.cc
+++ b/src/DHTFindNodeReplyMessage.cc
@@ -66,10 +66,10 @@ void DHTFindNodeReplyMessage::doReceivedAction()
 Dictionary* DHTFindNodeReplyMessage::getResponse()
 {
   Dictionary* a = new Dictionary();
-  a->put("id", new Data(reinterpret_cast<const char*>(_localNode->getID()),
-			DHT_ID_LENGTH));
+  a->put("id", new Data(_localNode->getID(), DHT_ID_LENGTH));
   size_t offset = 0;
-  char buffer[DHTBucket::K*26];
+  unsigned char buffer[DHTBucket::K*26];
+  // TODO if _closestKNodes.size() > DHTBucket::K ??
   for(std::deque<SharedHandle<DHTNode> >::const_iterator i = _closestKNodes.begin(); i != _closestKNodes.end(); ++i) {
     SharedHandle<DHTNode> node = *i;
     memcpy(buffer+offset, node->getID(), DHT_ID_LENGTH);
diff --git a/src/DHTGetPeersReplyMessage.cc b/src/DHTGetPeersReplyMessage.cc
index bdd6f609..725a9670 100644
--- a/src/DHTGetPeersReplyMessage.cc
+++ b/src/DHTGetPeersReplyMessage.cc
@@ -67,22 +67,21 @@ void DHTGetPeersReplyMessage::doReceivedAction()
 Dictionary* DHTGetPeersReplyMessage::getResponse()
 {
   Dictionary* r = new Dictionary();
-  r->put("id", new Data(reinterpret_cast<const char*>(_localNode->getID()),
-			DHT_ID_LENGTH));
+  r->put("id", new Data(_localNode->getID(), DHT_ID_LENGTH));
   r->put("token", new Data(_token));
   if(_values.size()) {
     List* valuesList = new List();
     r->put("values", valuesList);
     for(std::deque<SharedHandle<Peer> >::const_iterator i = _values.begin(); i != _values.end(); ++i) {
       const SharedHandle<Peer>& peer = *i;
-      char buffer[6];
+      unsigned char buffer[6];
       if(PeerMessageUtil::createcompact(buffer, peer->ipaddr, peer->port)) {
 	valuesList->add(new Data(buffer, sizeof(buffer)));
       }
     }
   } else {
     size_t offset = 0;
-    char buffer[DHTBucket::K*26];
+    unsigned char buffer[DHTBucket::K*26];
     for(std::deque<SharedHandle<DHTNode> >::const_iterator i = _closestKNodes.begin(); i != _closestKNodes.end(); ++i) {
       SharedHandle<DHTNode> node = *i;
       memcpy(buffer+offset, node->getID(), DHT_ID_LENGTH);
diff --git a/src/DHTMessage.cc b/src/DHTMessage.cc
index a77cf97d..5b1d07e4 100644
--- a/src/DHTMessage.cc
+++ b/src/DHTMessage.cc
@@ -52,7 +52,7 @@ DHTMessage::~DHTMessage() {}
 
 void DHTMessage::generateTransactionID()
 {
-  char tid[DHT_TRANSACTION_ID_LENGTH];
+  unsigned char tid[DHT_TRANSACTION_ID_LENGTH];
   DHTUtil::generateRandomData(tid, DHT_TRANSACTION_ID_LENGTH);
   _transactionID = std::string(&tid[0], &tid[DHT_TRANSACTION_ID_LENGTH]);
 }
diff --git a/src/DHTMessageFactory.h b/src/DHTMessageFactory.h
index fe9a71d6..a24c0490 100644
--- a/src/DHTMessageFactory.h
+++ b/src/DHTMessageFactory.h
@@ -108,8 +108,8 @@ public:
 				 const std::string& transactionID) = 0;
 
   virtual SharedHandle<DHTMessage>
-  createUnknownMessage(const char* data, size_t length, const std::string& ipaddr,
-		       uint16_t port) = 0;
+  createUnknownMessage(const unsigned char* data, size_t length,
+		       const std::string& ipaddr, uint16_t port) = 0;
 };
 
 } // namespace aria2
diff --git a/src/DHTMessageFactoryImpl.cc b/src/DHTMessageFactoryImpl.cc
index 001eeae7..d3fd88cb 100644
--- a/src/DHTMessageFactoryImpl.cc
+++ b/src/DHTMessageFactoryImpl.cc
@@ -160,7 +160,7 @@ SharedHandle<DHTMessage> DHTMessageFactoryImpl::createQueryMessage(const Diction
   }
   const Data* id = getData(getDictionary(d, "a"), "id");
   validateID(id);
-  SharedHandle<DHTNode> remoteNode = getRemoteNode((const unsigned char*)id->toString().c_str(), ipaddr, port);
+  SharedHandle<DHTNode> remoteNode = getRemoteNode(id->getData(), ipaddr, port);
   std::string messageType = q->toString();
   std::string transactionID = t->toString();
   if(messageType == "ping") {
@@ -168,34 +168,31 @@ SharedHandle<DHTMessage> DHTMessageFactoryImpl::createQueryMessage(const Diction
   } else if(messageType == "find_node") {
     const Data* targetNodeID = getData(a, "target");
     validateID(targetNodeID);
-    return createFindNodeMessage(remoteNode,
-				 (const unsigned char*)targetNodeID->getData(),
+    return createFindNodeMessage(remoteNode, targetNodeID->getData(),
 				 transactionID);
   } else if(messageType == "get_peers") {
     const Data* infoHash = getData(a, "info_hash");
     validateID(infoHash);
     return createGetPeersMessage(remoteNode,
-				 (const unsigned char*)infoHash->getData(),
-				 transactionID);
+				 infoHash->getData(), transactionID);
   } else if(messageType == "announce_peer") {
     const Data* infoHash = getData(a, "info_hash");
     validateID(infoHash);
     const Data* port = getData(a, "port");
     validatePort(port);
     const Data* token = getData(a, "token");
-    return createAnnouncePeerMessage(remoteNode,
-				     (const unsigned char*)infoHash->getData(),
-				     (uint16_t)port->toInt(),
-				     token->toString(),
-				     transactionID);
+    return createAnnouncePeerMessage(remoteNode, infoHash->getData(),
+				     static_cast<uint16_t>(port->toInt()),
+				     token->toString(), transactionID);
   } else {
     throw new DlAbortEx("Unsupported message type: %s", messageType.c_str());
   }
 }
 
-SharedHandle<DHTMessage> DHTMessageFactoryImpl::createResponseMessage(const std::string& messageType,
-							      const Dictionary* d,
-							      const SharedHandle<DHTNode>& remoteNode)
+SharedHandle<DHTMessage>
+DHTMessageFactoryImpl::createResponseMessage(const std::string& messageType,
+					     const Dictionary* d,
+					     const SharedHandle<DHTNode>& remoteNode)
 {
   const Data* t = getData(d, "t");
   const Data* y = getData(d, "y");
@@ -217,11 +214,11 @@ SharedHandle<DHTMessage> DHTMessageFactoryImpl::createResponseMessage(const std:
   const Dictionary* r = getDictionary(d, "r");
   const Data* id = getData(r, "id");
   validateID(id);
-  validateIDMatch(remoteNode->getID(),
-		      (const unsigned char*)id->toString().c_str());
+  validateIDMatch(remoteNode->getID(), id->getData());
   std::string transactionID = t->toString();
   if(messageType == "ping") {
-    return createPingReplyMessage(remoteNode, (const unsigned char*)id->getData(), transactionID);
+    return createPingReplyMessage(remoteNode,
+				  id->getData(), transactionID);
   } else if(messageType == "find_node") {
     return createFindNodeReplyMessage(remoteNode, d, transactionID);
   } else if(messageType == "get_peers") {
@@ -289,14 +286,15 @@ DHTMessageFactoryImpl::createFindNodeReplyMessage(const SharedHandle<DHTNode>& r
   return m;
 }
 
-std::deque<SharedHandle<DHTNode> > DHTMessageFactoryImpl::extractNodes(const char* src, size_t length)
+std::deque<SharedHandle<DHTNode> >
+DHTMessageFactoryImpl::extractNodes(const unsigned char* src, size_t length)
 {
   if(length%26 != 0) {
     throw new DlAbortEx("Nodes length is not multiple of 26");
   }
   std::deque<SharedHandle<DHTNode> > nodes;
   for(size_t offset = 0; offset < length; offset += 26) {
-    SharedHandle<DHTNode> node = new DHTNode(reinterpret_cast<const unsigned char*>(src+offset));
+    SharedHandle<DHTNode> node = new DHTNode(src+offset);
     std::pair<std::string, uint16_t> addr =
       PeerMessageUtil::unpackcompact(src+offset+DHT_ID_LENGTH);
     if(addr.first.empty()) {
@@ -419,7 +417,7 @@ DHTMessageFactoryImpl::createAnnouncePeerReplyMessage(const SharedHandle<DHTNode
 }
 
 SharedHandle<DHTMessage>
-DHTMessageFactoryImpl::createUnknownMessage(const char* data, size_t length,
+DHTMessageFactoryImpl::createUnknownMessage(const unsigned char* data, size_t length,
 					    const std::string& ipaddr, uint16_t port)
 
 {
diff --git a/src/DHTMessageFactoryImpl.h b/src/DHTMessageFactoryImpl.h
index 2c200552..dcffcdd1 100644
--- a/src/DHTMessageFactoryImpl.h
+++ b/src/DHTMessageFactoryImpl.h
@@ -74,7 +74,7 @@ private:
 
   void validatePort(const Data* i) const;
 
-  std::deque<SharedHandle<DHTNode> > extractNodes(const char* src, size_t length);
+  std::deque<SharedHandle<DHTNode> > extractNodes(const unsigned char* src, size_t length);
 
   void setCommonProperty(const SharedHandle<DHTAbstractMessage>& m);
 
@@ -156,8 +156,8 @@ public:
 				 const std::string& transactionID);
 
   virtual SharedHandle<DHTMessage>
-  createUnknownMessage(const char* data, size_t length, const std::string& ipaddr,
-		       uint16_t port);
+  createUnknownMessage(const unsigned char* data, size_t length,
+		       const std::string& ipaddr, uint16_t port);
 
   void setRoutingTable(const WeakHandle<DHTRoutingTable>& routingTable);
 
diff --git a/src/DHTMessageReceiver.cc b/src/DHTMessageReceiver.cc
index 795b3491..2522338d 100644
--- a/src/DHTMessageReceiver.cc
+++ b/src/DHTMessageReceiver.cc
@@ -65,7 +65,7 @@ SharedHandle<DHTMessage> DHTMessageReceiver::receiveMessage()
 {
   std::string remoteAddr;
   uint16_t remotePort;
-  char data[64*1024];
+  unsigned char data[64*1024];
   ssize_t length = _connection->receiveMessage(data, sizeof(data),
 					       remoteAddr,
 					       remotePort);
@@ -126,7 +126,8 @@ void DHTMessageReceiver::handleTimeout()
 }
 
 SharedHandle<DHTMessage>
-DHTMessageReceiver::handleUnknownMessage(const char* data, size_t length,
+DHTMessageReceiver::handleUnknownMessage(const unsigned char* data,
+					 size_t length,
 					 const std::string& remoteAddr,
 					 uint16_t remotePort)
 {
diff --git a/src/DHTMessageReceiver.h b/src/DHTMessageReceiver.h
index cc63b486..f77f3f09 100644
--- a/src/DHTMessageReceiver.h
+++ b/src/DHTMessageReceiver.h
@@ -61,7 +61,7 @@ private:
   const Logger* _logger;
 
   SharedHandle<DHTMessage>
-  handleUnknownMessage(const char* data, size_t length,
+  handleUnknownMessage(const unsigned char* data, size_t length,
 		       const std::string& remoteAddr, uint16_t remotePort);
 public:
   DHTMessageReceiver(const SharedHandle<DHTMessageTracker>& tracker);
diff --git a/src/DHTRoutingTableDeserializer.cc b/src/DHTRoutingTableDeserializer.cc
index 65392451..e749d097 100644
--- a/src/DHTRoutingTableDeserializer.cc
+++ b/src/DHTRoutingTableDeserializer.cc
@@ -126,7 +126,8 @@ void DHTRoutingTableDeserializer::deserialize(std::istream& in)
 	in.read(buf, 42);
 	continue;
       }
-      std::pair<std::string, uint16_t> peer = PeerMessageUtil::unpackcompact(buf);
+      std::pair<std::string, uint16_t> peer =
+	PeerMessageUtil::unpackcompact(reinterpret_cast<const unsigned char*>(buf));
       if(peer.first.empty()) {
 	// skip this entry
 	in.read(buf, 42);
diff --git a/src/DHTRoutingTableSerializer.cc b/src/DHTRoutingTableSerializer.cc
index 19772a8c..e2ffa1f1 100644
--- a/src/DHTRoutingTableSerializer.cc
+++ b/src/DHTRoutingTableSerializer.cc
@@ -101,7 +101,7 @@ void DHTRoutingTableSerializer::serialize(std::ostream& o)
       const SharedHandle<DHTNode>& node = *i;
       // Currently, only IPv4 address and IPv4-mapped address are saved.
       // 6bytes: write IP address + port in Compact IP-address/port info form.
-      char compactPeer[6];
+      unsigned char compactPeer[6];
       if(!PeerMessageUtil::createcompact(compactPeer, node->getIPAddress(), node->getPort())) {
 	memset(compactPeer, 0, 6);
       }
@@ -110,7 +110,7 @@ void DHTRoutingTableSerializer::serialize(std::ostream& o)
       // 7bytes reserved
       o.write(zero, 7);
       // 6 bytes compact peer
-      o.write(compactPeer, 6);
+      o.write(reinterpret_cast<const char*>(compactPeer), 6);
       // 2bytes reserved
       o.write(zero, 2);
       // 16bytes reserved
diff --git a/src/DHTTokenTracker.cc b/src/DHTTokenTracker.cc
index 70d7301d..cc64cbd9 100644
--- a/src/DHTTokenTracker.cc
+++ b/src/DHTTokenTracker.cc
@@ -48,7 +48,7 @@ DHTTokenTracker::DHTTokenTracker()
   memcpy(_secret[1], _secret[0], SECRET_SIZE);
 }
 
-DHTTokenTracker::DHTTokenTracker(const char* initialSecret)
+DHTTokenTracker::DHTTokenTracker(const unsigned char* initialSecret)
 {
   memcpy(_secret[0], initialSecret, SECRET_SIZE);
   memcpy(_secret[1], initialSecret, SECRET_SIZE);
@@ -58,9 +58,9 @@ DHTTokenTracker::~DHTTokenTracker() {}
 
 std::string DHTTokenTracker::generateToken(const unsigned char* infoHash,
 					   const std::string& ipaddr, uint16_t port,
-					   const char* secret) const
+					   const unsigned char* secret) const
 {
-  char src[DHT_ID_LENGTH+6+SECRET_SIZE];
+  unsigned char src[DHT_ID_LENGTH+6+SECRET_SIZE];
   if(!PeerMessageUtil::createcompact(src+DHT_ID_LENGTH, ipaddr, port)) {
     throw new DlAbortEx("Token generation failed: ipaddr=%s, port=%u",
 			ipaddr.c_str(), port);
diff --git a/src/DHTTokenTracker.h b/src/DHTTokenTracker.h
index 9fb2f788..32c4b3ac 100644
--- a/src/DHTTokenTracker.h
+++ b/src/DHTTokenTracker.h
@@ -44,15 +44,15 @@ class DHTTokenTracker {
 private:
   static const size_t SECRET_SIZE = 4;
 
-  char _secret[2][SECRET_SIZE];
+  unsigned char _secret[2][SECRET_SIZE];
 
   std::string generateToken(const unsigned char* infoHash,
 			    const std::string& ipaddr, uint16_t port,
-			    const char* secret) const;
+			    const unsigned char* secret) const;
 public:
   DHTTokenTracker();
 
-  DHTTokenTracker(const char* initialSecret);
+  DHTTokenTracker(const unsigned char* initialSecret);
 
   ~DHTTokenTracker();
 
diff --git a/src/DHTUnknownMessage.cc b/src/DHTUnknownMessage.cc
index a9836896..8d8aa140 100644
--- a/src/DHTUnknownMessage.cc
+++ b/src/DHTUnknownMessage.cc
@@ -40,7 +40,7 @@
 namespace aria2 {
 
 DHTUnknownMessage::DHTUnknownMessage(const SharedHandle<DHTNode>& localNode,
-				     const char* data, size_t length,
+				     const unsigned char* data, size_t length,
 				     const std::string& ipaddr, uint16_t port):
   DHTMessage(localNode, 0),
   _length(length),
@@ -50,7 +50,7 @@ DHTUnknownMessage::DHTUnknownMessage(const SharedHandle<DHTNode>& localNode,
   if(_length == 0) {
     _data = 0;
   } else {
-    _data = new char[length];
+    _data = new unsigned char[length];
     memcpy(_data, data, length);
   }
 }
diff --git a/src/DHTUnknownMessage.h b/src/DHTUnknownMessage.h
index 5f6c966d..76dce6d2 100644
--- a/src/DHTUnknownMessage.h
+++ b/src/DHTUnknownMessage.h
@@ -41,14 +41,14 @@ namespace aria2 {
 
 class DHTUnknownMessage:public DHTMessage {
 private:
-  char* _data;
+  unsigned char* _data;
   size_t _length;
   std::string _ipaddr;
   uint16_t _port;
 public:
   // _remoteNode is always null
   DHTUnknownMessage(const SharedHandle<DHTNode>& localNode,
-		    const char* data, size_t length,
+		    const unsigned char* data, size_t length,
 		    const std::string& ipaddr, uint16_t port);
 
   virtual ~DHTUnknownMessage();
diff --git a/src/DHTUtil.cc b/src/DHTUtil.cc
index fd54e6dd..ee82429e 100644
--- a/src/DHTUtil.cc
+++ b/src/DHTUtil.cc
@@ -48,7 +48,7 @@ namespace aria2 {
 
 void DHTUtil::generateRandomKey(unsigned char* key)
 {
-  char bytes[40];
+  unsigned char bytes[40];
   generateRandomData(bytes, sizeof(bytes));
   MessageDigestHelper::digest(key, 20, "sha1", bytes, sizeof(bytes));
 }
diff --git a/src/DHTUtil.h b/src/DHTUtil.h
index 7cb84faf..5ab0ab02 100644
--- a/src/DHTUtil.h
+++ b/src/DHTUtil.h
@@ -46,12 +46,7 @@ public:
   static void generateRandomKey(unsigned char* key);
 
   static void generateRandomData(unsigned char* data, size_t length);
-
-  static void generateRandomData(char* data, size_t length)
-  {
-    return generateRandomData(reinterpret_cast<unsigned char*>(data), length);
-  }
-
+  
   static void flipBit(unsigned char* data, size_t length, size_t bitIndex);
 
 };
diff --git a/src/Data.cc b/src/Data.cc
index 61cae140..45cacc36 100644
--- a/src/Data.cc
+++ b/src/Data.cc
@@ -38,23 +38,24 @@
 
 namespace aria2 {
 
-Data::Data(const char* data, int32_t len, bool number):number(number) {
+Data::Data(const unsigned char* data, int32_t len, bool number):number(number)
+{
   init(data, len);
 }
 
-Data::Data(const unsigned char* data, int32_t len, bool number):number(number) {
-  init(reinterpret_cast<const char*>(data), len);
+Data::Data(const char* data, int32_t len, bool number):number(number) {
+  init(reinterpret_cast<const unsigned char*>(data), len);
 }
 
 Data::Data(const std::string& data, bool number):number(number)
 {
-  init(data.c_str(), data.size());
+  init(reinterpret_cast<const unsigned char*>(data.c_str()), data.size());
 }
 
-void Data::init(const char* src, int32_t slen)
+void Data::init(const unsigned char* src, int32_t slen)
 {
   if(src) {
-    data = new char[slen];
+    data = new unsigned char[slen];
     memcpy(data, src, slen);
     len = slen;
   } else { 
@@ -71,7 +72,7 @@ std::string Data::toString() const {
   return std::string(&data[0], &data[len]);
 }
 
-const char* Data::getData() const {
+const unsigned char* Data::getData() const {
   if(this->len == 0) {
     return NULL;
   } else {
diff --git a/src/Data.h b/src/Data.h
index 977c9815..3d34a7bb 100644
--- a/src/Data.h
+++ b/src/Data.h
@@ -43,10 +43,10 @@ namespace aria2 {
 class Data : public MetaEntry {
 private:
   int32_t len;
-  char* data;
+  unsigned char* data;
   bool number;
 
-  void init(const char* data, int32_t len);
+  void init(const unsigned char* data, int32_t len);
 public:
   /**
    * This class stores the copy of data. So caller must take care of freeing
@@ -64,7 +64,7 @@ public:
   int32_t toInt() const;
   int64_t toLLInt() const;
   
-  const char* getData() const;
+  const unsigned char* getData() const;
   int32_t getLen() const;
   bool isNumber() const;
 
diff --git a/src/DefaultBtAnnounce.cc b/src/DefaultBtAnnounce.cc
index 25be7720..ed8d2d95 100644
--- a/src/DefaultBtAnnounce.cc
+++ b/src/DefaultBtAnnounce.cc
@@ -158,8 +158,7 @@ std::string DefaultBtAnnounce::getAnnounceUrl() {
     url += std::string("&")+"event="+event;
   }
   if(!trackerId.empty()) {
-    url += std::string("&")+"trackerid="+Util::torrentUrlencode((const unsigned char*)trackerId.c_str(),
-							   trackerId.size());
+    url += std::string("&")+"trackerid="+Util::torrentUrlencode(trackerId);
   }
   if(option->getAsBool(PREF_BT_REQUIRE_CRYPTO)) {
     url += "&requirecrypto=1";
@@ -193,7 +192,7 @@ void DefaultBtAnnounce::resetAnnounce() {
 }
 
 void
-DefaultBtAnnounce::processAnnounceResponse(const char* trackerResponse,
+DefaultBtAnnounce::processAnnounceResponse(const unsigned char* trackerResponse,
 					   size_t trackerResponseLength)
 {
   SharedHandle<MetaEntry> entry(MetaFileUtil::bdecoding(trackerResponse,
diff --git a/src/DefaultBtAnnounce.h b/src/DefaultBtAnnounce.h
index 77144a10..0c0818c3 100644
--- a/src/DefaultBtAnnounce.h
+++ b/src/DefaultBtAnnounce.h
@@ -107,7 +107,7 @@ public:
 
   virtual void resetAnnounce();
 
-  virtual void processAnnounceResponse(const char* trackerResponse,
+  virtual void processAnnounceResponse(const unsigned char* trackerResponse,
 				       size_t trackerResponseLength);
 
   virtual bool noMoreAnnounce();
diff --git a/src/DefaultBtContext.cc b/src/DefaultBtContext.cc
index ee15f4ed..3d9831c7 100644
--- a/src/DefaultBtContext.cc
+++ b/src/DefaultBtContext.cc
@@ -258,7 +258,9 @@ void DefaultBtContext::extractNodes(const List* nodes)
   }
 }
 
-void DefaultBtContext::loadFromMemory(const char* content, int32_t length, const std::string& defaultName)
+void DefaultBtContext::loadFromMemory(const unsigned char* content,
+				      int32_t length,
+				      const std::string& defaultName)
 {
   SharedHandle<MetaEntry> rootEntry = MetaFileUtil::bdecoding(content, length);
   const Dictionary* rootDic = dynamic_cast<const Dictionary*>(rootEntry.get());
@@ -310,8 +312,7 @@ void DefaultBtContext::processRootDictionary(const Dictionary* rootDic, const st
   }
   pieceLength = pieceLengthData->toInt();
   // retrieve piece hashes
-  extractPieceHash((unsigned char*)pieceHashData->getData(),
-		   pieceHashData->getLen(),
+  extractPieceHash(pieceHashData->getData(), pieceHashData->getLen(),
 		   PIECE_HASH_LENGTH);
   const Data* privateFlag = dynamic_cast<const Data*>(infoDic->get("private"));
   if(privateFlag) {
@@ -386,7 +387,7 @@ std::string DefaultBtContext::getActualBasePath() const
 std::deque<int32_t> DefaultBtContext::computeFastSet(const std::string& ipaddr, int32_t fastSetSize)
 {
   std::deque<int32_t> fastSet;
-  char compact[6];
+  unsigned char compact[6];
   if(!PeerMessageUtil::createcompact(compact, ipaddr, 0)) {
     return fastSet;
   }
diff --git a/src/DefaultBtContext.h b/src/DefaultBtContext.h
index 526d4d05..2b646002 100644
--- a/src/DefaultBtContext.h
+++ b/src/DefaultBtContext.h
@@ -119,7 +119,14 @@ private:
 
   virtual void load(const std::string& torrentFile);
 
-  void loadFromMemory(const char* content, int32_t length, const std::string& defaultName);
+  void loadFromMemory(const unsigned char* content, int32_t length,
+		      const std::string& defaultName);
+
+  void loadFromMemory(const std::string& context, const std::string& defaultName)
+  {
+    loadFromMemory(reinterpret_cast<const unsigned char*>(context.c_str()),
+		   context.size(), defaultName);
+  }
 
   virtual std::string getName() const;
 
@@ -133,7 +140,7 @@ private:
     if(peerId == "") {
       peerId = generatePeerId();
     }
-    return (const unsigned char*)peerId.c_str();
+    return reinterpret_cast<const unsigned char*>(peerId.c_str());
   }
 
   virtual std::deque<int32_t> computeFastSet(const std::string& ipaddr, int32_t fastSetSize);
diff --git a/src/DefaultBtMessageFactory.cc b/src/DefaultBtMessageFactory.cc
index 94d92d1e..f50e070a 100644
--- a/src/DefaultBtMessageFactory.cc
+++ b/src/DefaultBtMessageFactory.cc
@@ -187,7 +187,7 @@ DefaultBtMessageFactory::createBtMessage(const unsigned char* data, int32_t data
     }
     case BtExtendedMessage::ID: {
       if(peer->isExtendedMessagingEnabled()) {
-	msg = BtExtendedMessage::create(btContext, peer, (const char*)data, dataLength);
+	msg = BtExtendedMessage::create(btContext, peer, data, dataLength);
       } else {
 	throw new DlAbortEx("Received extended message from peer during a session with extended messaging disabled.");
       }
diff --git a/src/DefaultExtensionMessageFactory.cc b/src/DefaultExtensionMessageFactory.cc
index 65ba36fc..51bea129 100644
--- a/src/DefaultExtensionMessageFactory.cc
+++ b/src/DefaultExtensionMessageFactory.cc
@@ -58,7 +58,7 @@ DefaultExtensionMessageFactory::DefaultExtensionMessageFactory(const BtContextHa
 DefaultExtensionMessageFactory::~DefaultExtensionMessageFactory() {}
 
 ExtensionMessageHandle
-DefaultExtensionMessageFactory::createMessage(const char* data, size_t length)
+DefaultExtensionMessageFactory::createMessage(const unsigned char* data, size_t length)
 {
   uint8_t extensionMessageID = *data;
   if(extensionMessageID == 0) {
diff --git a/src/DefaultExtensionMessageFactory.h b/src/DefaultExtensionMessageFactory.h
index 0912c80e..4465bf46 100644
--- a/src/DefaultExtensionMessageFactory.h
+++ b/src/DefaultExtensionMessageFactory.h
@@ -60,7 +60,7 @@ public:
   virtual ~DefaultExtensionMessageFactory();
 
   virtual SharedHandle<ExtensionMessage>
-  createMessage(const char* data, size_t length);
+  createMessage(const unsigned char* data, size_t length);
 
   void setBtContext(const SharedHandle<BtContext>& btContext);
 
diff --git a/src/DownloadCommand.cc b/src/DownloadCommand.cc
index e9f0a29a..5e5a3a05 100644
--- a/src/DownloadCommand.cc
+++ b/src/DownloadCommand.cc
@@ -110,7 +110,7 @@ bool DownloadCommand::executeInternal() {
   SegmentHandle segment = _segments.front();
 
   int32_t BUFSIZE = 16*1024;
-  char buf[BUFSIZE];
+  unsigned char buf[BUFSIZE];
   int32_t bufSize;
   if(segment->getLength() > 0 && segment->getLength()-segment->getWrittenLength() < BUFSIZE) {
     bufSize = segment->getLength()-segment->getWrittenLength();
@@ -120,8 +120,8 @@ bool DownloadCommand::executeInternal() {
   socket->readData(buf, bufSize);
 
   if(transferDecoder.isNull()) {
-    _requestGroup->getPieceStorage()->getDiskAdaptor()->writeData((const unsigned char*)buf, bufSize,
-								segment->getPositionToWrite());
+    _requestGroup->getPieceStorage()->getDiskAdaptor()->writeData(buf, bufSize,
+								  segment->getPositionToWrite());
     //logger->debug("bufSize = %d, posToWrite = %lld", bufSize, segment->getPositionToWrite());
     segment->updateWrittenLength(bufSize);
     //logger->debug("overflow length = %d, next posToWrite = %lld", segment->getOverflowLength(), segment->getPositionToWrite());
@@ -131,10 +131,10 @@ bool DownloadCommand::executeInternal() {
     peerStat->updateDownloadLength(bufSize);
   } else {
     int32_t infbufSize = 16*1024;
-    char infbuf[infbufSize];
+    unsigned char infbuf[infbufSize];
     transferDecoder->inflate(infbuf, infbufSize, buf, bufSize);
-    _requestGroup->getPieceStorage()->getDiskAdaptor()->writeData((const unsigned char*)infbuf, infbufSize,
-								segment->getPositionToWrite());
+    _requestGroup->getPieceStorage()->getDiskAdaptor()->writeData(infbuf, infbufSize,
+								  segment->getPositionToWrite());
     segment->updateWrittenLength(infbufSize);
     //segment->writtenLength += infbufSize;
     peerStat->updateDownloadLength(infbufSize);
diff --git a/src/ExtensionMessageFactory.h b/src/ExtensionMessageFactory.h
index c239eaaa..9dd60b98 100644
--- a/src/ExtensionMessageFactory.h
+++ b/src/ExtensionMessageFactory.h
@@ -47,7 +47,7 @@ public:
   virtual ~ExtensionMessageFactory() {}
 
   virtual SharedHandle<ExtensionMessage>
-  createMessage(const char* data, size_t length) = 0;
+  createMessage(const unsigned char* data, size_t length) = 0;
 };
 
 typedef SharedHandle<ExtensionMessageFactory> ExtensionMessageFactoryHandle;
diff --git a/src/HandshakeExtensionMessage.cc b/src/HandshakeExtensionMessage.cc
index 4663c138..e6ac2ad5 100644
--- a/src/HandshakeExtensionMessage.cc
+++ b/src/HandshakeExtensionMessage.cc
@@ -132,7 +132,7 @@ uint8_t HandshakeExtensionMessage::getExtensionMessageID(const std::string& name
 }
 
 HandshakeExtensionMessageHandle
-HandshakeExtensionMessage::create(const char* data, size_t length)
+HandshakeExtensionMessage::create(const unsigned char* data, size_t length)
 {
   if(length < 1) {
     throw new DlAbortEx(MSG_TOO_SMALL_PAYLOAD_SIZE,
@@ -140,7 +140,7 @@ HandshakeExtensionMessage::create(const char* data, size_t length)
   }
   HandshakeExtensionMessageHandle msg = new HandshakeExtensionMessage();
   msg->_logger->debug("Creating HandshakeExtensionMessage from %s",
-		      Util::urlencode((const unsigned char*)data, length).c_str());
+		      Util::urlencode(data, length).c_str());
   SharedHandle<MetaEntry> root = MetaFileUtil::bdecoding(data+1, length-1);
   Dictionary* d = dynamic_cast<Dictionary*>(root.get());
   if(d == 0) {
diff --git a/src/HandshakeExtensionMessage.h b/src/HandshakeExtensionMessage.h
index aea6563e..201891a0 100644
--- a/src/HandshakeExtensionMessage.h
+++ b/src/HandshakeExtensionMessage.h
@@ -120,9 +120,8 @@ public:
 
   void setBtContext(const SharedHandle<BtContext>& btContext);
 
-  static HandshakeExtensionMessageHandle create(const char* data,
+  static HandshakeExtensionMessageHandle create(const unsigned char* data,
 						size_t dataLength);
-
 };
 
 typedef SharedHandle<HandshakeExtensionMessage> HandshakeExtensionMessageHandle;
diff --git a/src/HttpConnection.cc b/src/HttpConnection.cc
index 5938c915..cd00a057 100644
--- a/src/HttpConnection.cc
+++ b/src/HttpConnection.cc
@@ -117,7 +117,7 @@ HttpResponseHandle HttpConnection::receiveResponse()
   HttpRequestEntryHandle entry = outstandingHttpRequests.front();
   HttpHeaderProcessorHandle proc = entry->getHttpHeaderProcessor();
 
-  char buf[512];
+  unsigned char buf[512];
   int32_t size = sizeof(buf);
   socket->peekData(buf, size);
   if(size == 0) {
diff --git a/src/HttpHeaderProcessor.cc b/src/HttpHeaderProcessor.cc
index 0bd540eb..9cbaa6a8 100644
--- a/src/HttpHeaderProcessor.cc
+++ b/src/HttpHeaderProcessor.cc
@@ -45,10 +45,10 @@ HttpHeaderProcessor::HttpHeaderProcessor():_limit(4096) {}
 
 HttpHeaderProcessor::~HttpHeaderProcessor() {}
 
-void HttpHeaderProcessor::update(const char* data, int32_t length)
+void HttpHeaderProcessor::update(const unsigned char* data, int32_t length)
 {
   checkHeaderLimit(length);
-  strm.write(data, length);
+  strm.write(reinterpret_cast<const char*>(data), length);
 }
 
 void HttpHeaderProcessor::update(const std::string& data)
diff --git a/src/HttpHeaderProcessor.h b/src/HttpHeaderProcessor.h
index e0a5dda7..84fd14a3 100644
--- a/src/HttpHeaderProcessor.h
+++ b/src/HttpHeaderProcessor.h
@@ -56,7 +56,7 @@ public:
 
   ~HttpHeaderProcessor();
 
-  void update(const char* data, int32_t length);
+  void update(const unsigned char* data, int32_t length);
 
   void update(const std::string& data);
 
diff --git a/src/MetaFileUtil.cc b/src/MetaFileUtil.cc
index 9f5ea173..a4e15b60 100644
--- a/src/MetaFileUtil.cc
+++ b/src/MetaFileUtil.cc
@@ -45,11 +45,11 @@ namespace aria2 {
 
 MetaEntry* MetaFileUtil::parseMetaFile(const std::string& file) {
   File f(file);
-  int32_t len = f.size();
-  char* buf = new char[len];
+  size_t len = f.size();
+  unsigned char* buf = new unsigned char[len];
   FILE* fp = fopen(file.c_str(), "r+b");
   try {
-    if(fp == NULL) {
+    if(!fp) {
       throw new DlAbortEx("cannot open metainfo file");
     }
     if(fread(buf, len, 1, fp) != 1) {
@@ -57,35 +57,29 @@ MetaEntry* MetaFileUtil::parseMetaFile(const std::string& file) {
       throw new DlAbortEx("cannot read metainfo");
     }
     fclose(fp);
-    fp = NULL;
+    fp = 0;
     MetaEntry* entry = bdecoding(buf, len);
     delete [] buf;
     return entry;
   } catch(RecoverableException* ex) {
     delete [] buf;
-    if(fp != NULL) {
+    if(fp) {
       fclose(fp);
     }
     throw;
   }
 }
 
-MetaEntry* MetaFileUtil::bdecoding(const char* buf, int32_t len) {
-  MetaEntry* entry = NULL;
-  try{
-    const char* p = buf;
-    const char* end = buf+len;
-    entry = bdecodingR(&p, end);
-    return entry;
-  } catch(RecoverableException* ex) {
-    if(entry != NULL) {
-      delete entry;
-    }
-    throw;
-  }
+MetaEntry* MetaFileUtil::bdecoding(const unsigned char* buf, size_t len)
+{
+  const unsigned char* p = buf;
+  const unsigned char* end = buf+len;
+  return bdecodingR(&p, end);
 }
 
-MetaEntry* MetaFileUtil::bdecodingR(const char** pp, const char* end) {
+MetaEntry*
+MetaFileUtil::bdecodingR(const unsigned char** pp, const unsigned char* end)
+{
   if(*pp >= end) {
     throw new DlAbortEx("Malformed metainfo");
   }
@@ -109,7 +103,9 @@ MetaEntry* MetaFileUtil::bdecodingR(const char** pp, const char* end) {
   return e;
 }
 
-Dictionary* MetaFileUtil::parseDictionaryTree(const char** pp, const char* end) {
+Dictionary*
+MetaFileUtil::parseDictionaryTree(const unsigned char** pp, const unsigned char* end)
+{
   if(*pp >= end) {
     throw new DlAbortEx("Malformed metainfo");
   }
@@ -131,7 +127,9 @@ Dictionary* MetaFileUtil::parseDictionaryTree(const char** pp, const char* end)
   }
 }
 
-List* MetaFileUtil::parseListTree(const char** pp, const char* end) {
+List*
+MetaFileUtil::parseListTree(const unsigned char** pp, const unsigned char* end)
+{
   if(*pp >= end) {
     throw new DlAbortEx("Malformed metainfo");
   }
@@ -152,37 +150,42 @@ List* MetaFileUtil::parseListTree(const char** pp, const char* end) {
   }
 }
 
-Data* MetaFileUtil::decodeInt(const char** pp, const char* end) {
+Data*
+MetaFileUtil::decodeInt(const unsigned char** pp, const unsigned char* end)
+{
   if(*pp >= end) {
     throw new DlAbortEx(EX_MALFORMED_META_INFO);
   }
-  char* endTerm = (char*)memchr(*pp, 'e', end-*pp);
+  unsigned char* endTerm = reinterpret_cast<unsigned char*>(memchr(*pp, 'e', end-*pp));
   // TODO if endTerm is null
-  if(endTerm == NULL) {
+  if(!endTerm) {
     throw new DlAbortEx(EX_MALFORMED_META_INFO);
   }
-  int32_t numSize = endTerm-*pp;
+  size_t numSize = endTerm-*pp;
 
   Data* data = new Data(*pp, numSize, true);
   *pp += numSize+1;
   return data;
 }
 
-Data* MetaFileUtil::decodeWord(const char** pp, const char* end) {
+Data*
+MetaFileUtil::decodeWord(const unsigned char** pp, const unsigned char* end)
+{
   if(*pp >= end) {
     throw new DlAbortEx("Malformed metainfo");
   }
-  char* delim = (char*)memchr(*pp, ':', end-*pp);
+  unsigned char* delim = reinterpret_cast<unsigned char*>(memchr(*pp, ':', end-*pp));
   // TODO if delim is null
-  if(delim == *pp || delim == NULL) {
+  if(delim == *pp || !delim) {
     throw new DlAbortEx(EX_MALFORMED_META_INFO);
   }
-  int32_t numSize = delim-*pp;
-  char* temp = new char[numSize+1];
+  size_t numSize = delim-*pp;
+  unsigned char* temp = new unsigned char[numSize+1];
   memcpy(temp, *pp, numSize);
   temp[numSize] = '\0';
   char* endptr;
-  int32_t size = strtol(temp, &endptr, 10);
+  unsigned long int size = strtoul(reinterpret_cast<const char*>(temp),
+				   &endptr, 10);
   if(*endptr != '\0') {
     delete [] temp;
     throw new DlAbortEx(EX_MALFORMED_META_INFO);
@@ -198,7 +201,9 @@ Data* MetaFileUtil::decodeWord(const char** pp, const char* end) {
   return data;
 }
 
-std::string MetaFileUtil::decodeWordAsString(const char** pp, const char* end) {
+std::string
+MetaFileUtil::decodeWordAsString(const unsigned char** pp, const unsigned char* end)
+{
   Data* data = decodeWord(pp, end);
   std::string str = data->toString();
   delete data;
diff --git a/src/MetaFileUtil.h b/src/MetaFileUtil.h
index fdcae8c1..b29b948e 100644
--- a/src/MetaFileUtil.h
+++ b/src/MetaFileUtil.h
@@ -49,16 +49,22 @@ class MetaFileUtil {
 private:
   MetaFileUtil() {}
 
-  static MetaEntry* bdecodingR(const char** pp, const char* end);
-  static Dictionary* parseDictionaryTree(const char** pp, const char* end);
-  static List* parseListTree(const char** pp, const char* end);
-  static Data* decodeWord(const char** pp, const char* end);
-  static Data* decodeInt(const char** pp, const char* end);
-  static std::string decodeWordAsString(const char** pp, const char* end);
+  static MetaEntry* bdecodingR(const unsigned char** pp, const unsigned char* end);
+  static Dictionary* parseDictionaryTree(const unsigned char** pp, const unsigned char* end);
+  static List* parseListTree(const unsigned char** pp, const unsigned char* end);
+  static Data* decodeWord(const unsigned char** pp, const unsigned char* end);
+  static Data* decodeInt(const unsigned char** pp, const unsigned char* end);
+  static std::string decodeWordAsString(const unsigned char** pp, const unsigned char* end);
 
 public:
   static MetaEntry* parseMetaFile(const std::string& file);
-  static MetaEntry* bdecoding(const char* buf, int32_t len);
+  static MetaEntry* bdecoding(const unsigned char* buf, size_t len);
+
+  static MetaEntry* bdecoding(const std::string& content)
+  {
+    return bdecoding(reinterpret_cast<const unsigned char*>(content.c_str()),
+		     content.size());
+  }
 };
 
 } // namespace aria2
diff --git a/src/PeerConnection.cc b/src/PeerConnection.cc
index e528ec1c..aaffe8da 100644
--- a/src/PeerConnection.cc
+++ b/src/PeerConnection.cc
@@ -160,14 +160,13 @@ bool PeerConnection::receiveHandshake(unsigned char* data, int32_t& dataLength,
   return retval;
 }
 
-void PeerConnection::readData(char* data, int32_t& length, bool encryption)
+void PeerConnection::readData(unsigned char* data, int32_t& length, bool encryption)
 {
   if(encryption) {
-    unsigned char* cdata = reinterpret_cast<unsigned char*>(data);
     unsigned char temp[MAX_PAYLOAD_LEN];
     assert(MAX_PAYLOAD_LEN >= length);
     socket->readData(temp, length);
-    _decryptor->decrypt(cdata, length, temp, length);
+    _decryptor->decrypt(data, length, temp, length);
   } else {
     socket->readData(data, length);
   }
diff --git a/src/PeerConnection.h b/src/PeerConnection.h
index 5dad0fca..346a2e8e 100644
--- a/src/PeerConnection.h
+++ b/src/PeerConnection.h
@@ -57,17 +57,17 @@ private:
   const Option* option;
   const Logger* logger;
 
-  char resbuf[MAX_PAYLOAD_LEN];
+  unsigned char resbuf[MAX_PAYLOAD_LEN];
   int32_t resbufLength;
   int32_t currentPayloadLength;
-  char lenbuf[4];
+  unsigned char lenbuf[4];
   int32_t lenbufLength;
 
   bool _encryptionEnabled;
   SharedHandle<ARC4Encryptor> _encryptor;
   SharedHandle<ARC4Decryptor> _decryptor;
 
-  void readData(char* data, int32_t& length, bool encryption);
+  void readData(unsigned char* data, int32_t& length, bool encryption);
 
   void sendData(const unsigned char* data, size_t length, bool encryption);
 
diff --git a/src/PeerMessageUtil.cc b/src/PeerMessageUtil.cc
index d12b55f5..a6329da2 100644
--- a/src/PeerMessageUtil.cc
+++ b/src/PeerMessageUtil.cc
@@ -125,7 +125,8 @@ void PeerMessageUtil::createPeerMessageString(unsigned char* msg,
   msg[4] = messageId;
 }
 
-bool PeerMessageUtil::createcompact(char* compact, const std::string& addr, uint16_t port)
+bool
+PeerMessageUtil::createcompact(unsigned char* compact, const std::string& addr, uint16_t port)
 {
   struct addrinfo hints;
   struct addrinfo* res;
@@ -144,7 +145,8 @@ bool PeerMessageUtil::createcompact(char* compact, const std::string& addr, uint
   return true;
 }
 
-std::pair<std::string, uint16_t> PeerMessageUtil::unpackcompact(const char* compact)
+std::pair<std::string, uint16_t>
+PeerMessageUtil::unpackcompact(const unsigned char* compact)
 {
   struct sockaddr_in in;
   memset(&in, 0, sizeof(in));
diff --git a/src/PeerMessageUtil.h b/src/PeerMessageUtil.h
index c2446c1c..cdb8984b 100644
--- a/src/PeerMessageUtil.h
+++ b/src/PeerMessageUtil.h
@@ -78,9 +78,9 @@ public:
    * The example of failure reason is that addr is not numbers-and-dots
    * notation.
    */
-  static bool createcompact(char* compact, const std::string& addr, uint16_t port);
+  static bool createcompact(unsigned char* compact, const std::string& addr, uint16_t port);
 
-  static std::pair<std::string, uint16_t> unpackcompact(const char* compact);
+  static std::pair<std::string, uint16_t> unpackcompact(const unsigned char* compact);
 };
 
 } // namespace aria2
diff --git a/src/SocketCore.h b/src/SocketCore.h
index d0431472..a7a54bcd 100644
--- a/src/SocketCore.h
+++ b/src/SocketCore.h
@@ -190,6 +190,12 @@ public:
 
   void writeData(const char* data, size_t len, const std::string& host, uint16_t port);
 
+  void writeData(const unsigned char* data, size_t len, const std::string& host,
+		 uint16_t port)
+  {
+    writeData(reinterpret_cast<const char*>(data), len, host, port);
+  }
+
   /**
    * Reads up to len bytes from this socket.
    * data is a pointer pointing the first
@@ -209,10 +215,17 @@ public:
     readData(reinterpret_cast<char*>(data), len);
   }
 
-  ssize_t readDataFrom(char*, size_t len,
+  ssize_t readDataFrom(char* data, size_t len,
 		       std::pair<std::string /* numerichost */,
 		       uint16_t /* port */>& sender);
 
+  ssize_t readDataFrom(unsigned char* data, size_t len,
+		       std::pair<std::string /* numerichost */,
+		       uint16_t /* port */>& sender)
+  {
+    return readDataFrom(reinterpret_cast<char*>(data), len, sender);
+  }
+			
   /**
    * Reads up to len bytes from this socket, but bytes are not removed from
    * this socket.
diff --git a/src/TrackerWatcherCommand.cc b/src/TrackerWatcherCommand.cc
index af740333..c367fa5e 100644
--- a/src/TrackerWatcherCommand.cc
+++ b/src/TrackerWatcherCommand.cc
@@ -125,11 +125,11 @@ bool TrackerWatcherCommand::execute() {
 std::string TrackerWatcherCommand::getTrackerResponse(const RequestGroupHandle& requestGroup)
 {
   std::stringstream strm;
-  char data[2048];
+  unsigned char data[2048];
   requestGroup->getPieceStorage()->getDiskAdaptor()->openFile();
   while(1) {
-    int32_t dataLength = requestGroup->getPieceStorage()->getDiskAdaptor()->readData((unsigned char*)data, sizeof(data), strm.tellp());
-    strm.write(data, dataLength);
+    int32_t dataLength = requestGroup->getPieceStorage()->getDiskAdaptor()->readData(data, sizeof(data), strm.tellp());
+    strm.write(reinterpret_cast<const char*>(data), dataLength);
     if(dataLength == 0) {
       break;
     }
@@ -140,7 +140,7 @@ std::string TrackerWatcherCommand::getTrackerResponse(const RequestGroupHandle&
 // TODO we have to deal with the exception thrown By BtAnnounce
 void TrackerWatcherCommand::processTrackerResponse(const std::string& trackerResponse)
 {
-  btAnnounce->processAnnounceResponse(trackerResponse.c_str(),
+  btAnnounce->processAnnounceResponse(reinterpret_cast<const unsigned char*>(trackerResponse.c_str()),
 				      trackerResponse.size());
   while(!btRuntime->isHalt() && btRuntime->lessThanMinPeer()) {
     PeerHandle peer = peerStorage->getUnusedPeer();
diff --git a/src/TransferEncoding.h b/src/TransferEncoding.h
index 8a644029..406f1724 100644
--- a/src/TransferEncoding.h
+++ b/src/TransferEncoding.h
@@ -45,7 +45,8 @@ class TransferEncoding {
 public:
   virtual ~TransferEncoding() {}
   virtual void init() = 0;
-  virtual void inflate(char* outbuf, int32_t& outlen, const char* inbuf, int32_t inlen) = 0;
+  virtual void inflate(unsigned char* outbuf, int32_t& outlen,
+		       const unsigned char* inbuf, int32_t inlen) = 0;
   virtual bool finished() = 0;
   virtual void end() = 0;
 };
diff --git a/src/UTPexExtensionMessage.cc b/src/UTPexExtensionMessage.cc
index f1e9ffcd..c94d4554 100644
--- a/src/UTPexExtensionMessage.cc
+++ b/src/UTPexExtensionMessage.cc
@@ -76,7 +76,7 @@ std::pair<std::string, std::string> UTPexExtensionMessage::createCompactPeerList
   std::string addrstring;
   std::string flagstring;
   for(Peers::const_iterator itr = peers.begin(); itr != peers.end(); ++itr) {
-    char compact[6];
+    unsigned char compact[6];
     if(PeerMessageUtil::createcompact(compact, (*itr)->ipaddr, (*itr)->port)) {
       addrstring.append(&compact[0], &compact[6]);
       flagstring += (*itr)->isSeeder() ? "2" : "0";
@@ -123,7 +123,7 @@ void UTPexExtensionMessage::setBtContext(const BtContextHandle& btContext)
 
 UTPexExtensionMessageHandle
 UTPexExtensionMessage::create(const BtContextHandle& btContext,
-			      const char* data, size_t len)
+			      const unsigned char* data, size_t len)
 {
   if(len < 1) {
     throw new DlAbortEx(MSG_TOO_SMALL_PAYLOAD_SIZE,
diff --git a/src/UTPexExtensionMessage.h b/src/UTPexExtensionMessage.h
index 4d670d8e..04956796 100644
--- a/src/UTPexExtensionMessage.h
+++ b/src/UTPexExtensionMessage.h
@@ -93,7 +93,7 @@ public:
   void setBtContext(const SharedHandle<BtContext>& btContext);
 
   static UTPexExtensionMessageHandle create(const SharedHandle<BtContext>& btContext,
-					    const char* data, size_t len);
+					    const unsigned char* data, size_t len);
 };
 
 typedef SharedHandle<UTPexExtensionMessage> UTPexExtensionMessageHandle;
diff --git a/src/Util.h b/src/Util.h
index bb045ff0..6013ba56 100644
--- a/src/Util.h
+++ b/src/Util.h
@@ -137,6 +137,12 @@ public:
 
   static std::string torrentUrlencode(const unsigned char* target, int32_t len);
 
+  static std::string torrentUrlencode(const std::string& target)
+  {
+    return torrentUrlencode(reinterpret_cast<const unsigned char*>(target.c_str()),
+			    target.size());
+  }
+
   static std::string toHex(const unsigned char* src, int32_t len);
 
   static std::string toHex(const std::string& src)