ipc/ipc_message_utils.cc

   1 // Copyright (c) 2011 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include "ipc/ipc_message_utils.h"
   6
   7 //#include "base/file_path.h"
   8 //#include "base/json/json_writer.h"
   9 //#include "base/memory/scoped_ptr.h"
  10 //#include "base/nullable_string16.h"
  11 #include "base/string_number_conversions.h"
  12 #include "base/time.h"
  13 //#include "base/utf_string_conversions.h"
  14 #include "base/values.h"
  15 #if defined(OS_POSIX)
  16 //#include "ipc/file_descriptor_set_posix.h"
  17 #endif
  18 //#include "ipc/ipc_channel_handle.h"
  19
  20 namespace IPC {
  21
  22 const int kMaxRecursionDepth = 100;
  23
  24 // Value serialization
  25
  26 /*
  27 static bool ReadValue(const Message* m, void** iter, Value** value,
  28                       int recursion);
  29
  30 static void WriteValue(Message* m, const Value* value, int recursion) {
  31   if (recursion > kMaxRecursionDepth) {
  32     LOG(WARNING) << "Max recursion depth hit in WriteValue.";
  33     return;
  34   }
  35
  36   m->WriteInt(value->GetType());
  37
  38   switch (value->GetType()) {
  39     case Value::TYPE_NULL:
  40     break;
  41     case Value::TYPE_BOOLEAN: {
  42       bool val;
  43       value->GetAsBoolean(&val);
  44       WriteParam(m, val);
  45       break;
  46     }
  47     case Value::TYPE_INTEGER: {
  48       int val;
  49       value->GetAsInteger(&val);
  50       WriteParam(m, val);
  51       break;
  52     }
  53     case Value::TYPE_DOUBLE: {
  54       double val;
  55       value->GetAsDouble(&val);
  56       WriteParam(m, val);
  57       break;
  58     }
  59     case Value::TYPE_STRING: {
  60       std::string val;
  61       value->GetAsString(&val);
  62       WriteParam(m, val);
  63       break;
  64     }
  65     case Value::TYPE_BINARY: {
  66       const base::BinaryValue* binary =
  67           static_cast<const base::BinaryValue*>(value);
  68       m->WriteData(binary->GetBuffer(), static_cast<int>(binary->GetSize()));
  69       break;
  70     }
  71     case Value::TYPE_DICTIONARY: {
  72       const DictionaryValue* dict = static_cast<const DictionaryValue*>(value);
  73
  74       WriteParam(m, static_cast<int>(dict->size()));
  75
  76       for (DictionaryValue::key_iterator it = dict->begin_keys();
  77            it != dict->end_keys(); ++it) {
  78         Value* subval;
  79         if (dict->GetWithoutPathExpansion(*it, &subval)) {
  80           WriteParam(m, *it);
  81           WriteValue(m, subval, recursion + 1);
  82         } else {
  83           NOTREACHED() << "DictionaryValue iterators are filthy liars.";
  84         }
  85       }
  86       break;
  87     }
  88     case Value::TYPE_LIST: {
  89       const ListValue* list = static_cast<const ListValue*>(value);
  90       WriteParam(m, static_cast<int>(list->GetSize()));
  91       for (size_t i = 0; i < list->GetSize(); ++i) {
  92         Value* subval;
  93         if (list->Get(i, &subval)) {
  94           WriteValue(m, subval, recursion + 1);
  95         } else {
  96           NOTREACHED() << "ListValue::GetSize is a filthy liar.";
  97         }
  98       }
  99       break;
 100     }
 101   }
 102 }
 103
 104 // Helper for ReadValue that reads a DictionaryValue into a pre-allocated
 105 // object.
 106 static bool ReadDictionaryValue(const Message* m, void** iter,
 107                                 DictionaryValue* value, int recursion) {
 108   int size;
 109   if (!ReadParam(m, iter, &size))
 110     return false;
 111
 112   for (int i = 0; i < size; ++i) {
 113     std::string key;
 114     Value* subval;
 115     if (!ReadParam(m, iter, &key) ||
 116         !ReadValue(m, iter, &subval, recursion + 1))
 117       return false;
 118     value->Set(key, subval);
 119   }
 120
 121   return true;
 122 }
 123
 124 // Helper for ReadValue that reads a ReadListValue into a pre-allocated
 125 // object.
 126 static bool ReadListValue(const Message* m, void** iter,
 127                           ListValue* value, int recursion) {
 128   int size;
 129   if (!ReadParam(m, iter, &size))
 130     return false;
 131
 132   for (int i = 0; i < size; ++i) {
 133     Value* subval;
 134     if (!ReadValue(m, iter, &subval, recursion + 1))
 135       return false;
 136     value->Set(i, subval);
 137   }
 138
 139   return true;
 140 }
 141
 142 static bool ReadValue(const Message* m, void** iter, Value** value,
 143                       int recursion) {
 144   if (recursion > kMaxRecursionDepth) {
 145     LOG(WARNING) << "Max recursion depth hit in ReadValue.";
 146     return false;
 147   }
 148
 149   int type;
 150   if (!ReadParam(m, iter, &type))
 151     return false;
 152
 153   switch (type) {
 154     case Value::TYPE_NULL:
 155     *value = Value::CreateNullValue();
 156     break;
 157     case Value::TYPE_BOOLEAN: {
 158       bool val;
 159       if (!ReadParam(m, iter, &val))
 160         return false;
 161       *value = Value::CreateBooleanValue(val);
 162       break;
 163     }
 164     case Value::TYPE_INTEGER: {
 165       int val;
 166       if (!ReadParam(m, iter, &val))
 167         return false;
 168       *value = Value::CreateIntegerValue(val);
 169       break;
 170     }
 171     case Value::TYPE_DOUBLE: {
 172       double val;
 173       if (!ReadParam(m, iter, &val))
 174         return false;
 175       *value = Value::CreateDoubleValue(val);
 176       break;
 177     }
 178     case Value::TYPE_STRING: {
 179       std::string val;
 180       if (!ReadParam(m, iter, &val))
 181         return false;
 182       *value = Value::CreateStringValue(val);
 183       break;
 184     }
 185     case Value::TYPE_BINARY: {
 186       const char* data;
 187       int length;
 188       if (!m->ReadData(iter, &data, &length))
 189         return false;
 190       *value = base::BinaryValue::CreateWithCopiedBuffer(data, length);
 191       break;
 192     }
 193     case Value::TYPE_DICTIONARY: {
 194       scoped_ptr<DictionaryValue> val(new DictionaryValue());
 195       if (!ReadDictionaryValue(m, iter, val.get(), recursion))
 196         return false;
 197       *value = val.release();
 198       break;
 199     }
 200     case Value::TYPE_LIST: {
 201       scoped_ptr<ListValue> val(new ListValue());
 202       if (!ReadListValue(m, iter, val.get(), recursion))
 203         return false;
 204       *value = val.release();
 205       break;
 206     }
 207     default:
 208     return false;
 209   }
 210
 211   return true;
 212 }
 213 */
 214
 215 void ParamTraits<int>::Log(const param_type& p, std::string* l) {
 216   //l->append(base::IntToString(p));
 217 }
 218
 219 void ParamTraits<unsigned int>::Log(const param_type& p, std::string* l) {
 220   //l->append(base::UintToString(p));
 221 }
 222
 223 void ParamTraits<long>::Log(const param_type& p, std::string* l) {
 224   //l->append(base::Int64ToString(static_cast<int64>(p)));
 225 }
 226
 227 void ParamTraits<unsigned long>::Log(const param_type& p, std::string* l) {
 228   //l->append(base::Uint64ToString(static_cast<uint64>(p)));
 229 }
 230
 231 void ParamTraits<long long>::Log(const param_type& p, std::string* l) {
 232   //l->append(base::Int64ToString(static_cast<int64>(p)));
 233 }
 234
 235 void ParamTraits<unsigned long long>::Log(const param_type& p, std::string* l) {
 236   //l->append(base::Uint64ToString(p));
 237 }
 238
 239
 240 void ParamTraits<unsigned short>::Write(Message* m, const param_type& p) {
 241   m->WriteBytes(&p, sizeof(param_type));
 242 }
 243
 244 bool ParamTraits<unsigned short>::Read(const Message* m, void** iter,
 245                                        param_type* r) {
 246   const char* data;
 247   if (!m->ReadBytes(iter, &data, sizeof(param_type)))
 248     return false;
 249   memcpy(r, data, sizeof(param_type));
 250   return true;
 251 }
 252
 253 /*
 254 void ParamTraits<unsigned short>::Log(const param_type& p, std::string* l) {
 255   l->append(base::UintToString(p));
 256 }
 257
 258
 259 void ParamTraits<base::Time>::Write(Message* m, const param_type& p) {
 260   ParamTraits<int64>::Write(m, p.ToInternalValue());
 261 }
 262
 263 bool ParamTraits<base::Time>::Read(const Message* m, void** iter,
 264                                    param_type* r) {
 265   int64 value;
 266   if (!ParamTraits<int64>::Read(m, iter, &value))
 267     return false;
 268   *r = base::Time::FromInternalValue(value);
 269   return true;
 270 }
 271
 272 void ParamTraits<base::Time>::Log(const param_type& p, std::string* l) {
 273   ParamTraits<int64>::Log(p.ToInternalValue(), l);
 274 }
 275
 276 void ParamTraits<base::TimeDelta> ::Write(Message* m, const param_type& p) {
 277   ParamTraits<int64> ::Write(m, p.InMicroseconds());
 278 }
 279
 280 bool ParamTraits<base::TimeDelta> ::Read(const Message* m,
 281                                          void** iter,
 282                                          param_type* r) {
 283   int64 value;
 284   bool ret = ParamTraits<int64> ::Read(m, iter, &value);
 285   if (ret)
 286     *r = base::TimeDelta::FromMicroseconds(value);
 287
 288   return ret;
 289 }
 290
 291 void ParamTraits<base::TimeDelta> ::Log(const param_type& p, std::string* l) {
 292   ParamTraits<int64> ::Log(p.InMicroseconds(), l);
 293 }
 294
 295 void ParamTraits<DictionaryValue>::Write(Message* m, const param_type& p) {
 296   WriteValue(m, &p, 0);
 297 }
 298
 299 bool ParamTraits<DictionaryValue>::Read(
 300     const Message* m, void** iter, param_type* r) {
 301   int type;
 302   if (!ReadParam(m, iter, &type) || type != Value::TYPE_DICTIONARY)
 303     return false;
 304
 305   return ReadDictionaryValue(m, iter, r, 0);
 306 }
 307
 308 void ParamTraits<DictionaryValue>::Log(const param_type& p, std::string* l) {
 309   std::string json;
 310   base::JSONWriter::Write(&p, false, &json);
 311   l->append(json);
 312 }
 313
 314 void ParamTraits<ListValue>::Write(Message* m, const param_type& p) {
 315   WriteValue(m, &p, 0);
 316 }
 317
 318 bool ParamTraits<ListValue>::Read(
 319     const Message* m, void** iter, param_type* r) {
 320   int type;
 321   if (!ReadParam(m, iter, &type) || type != Value::TYPE_LIST)
 322     return false;
 323
 324   return ReadListValue(m, iter, r, 0);
 325 }
 326
 327 void ParamTraits<ListValue>::Log(const param_type& p, std::string* l) {
 328   std::string json;
 329   base::JSONWriter::Write(&p, false, &json);
 330   l->append(json);
 331 }
 332
 333 void ParamTraits<std::wstring>::Log(const param_type& p, std::string* l) {
 334   l->append(WideToUTF8(p));
 335 }
 336
 337 void ParamTraits<NullableString16>::Write(Message* m, const param_type& p) {
 338   WriteParam(m, p.string());
 339   WriteParam(m, p.is_null());
 340 }
 341
 342 bool ParamTraits<NullableString16>::Read(const Message* m, void** iter,
 343                                          param_type* r) {
 344   string16 string;
 345   if (!ReadParam(m, iter, &string))
 346     return false;
 347   bool is_null;
 348   if (!ReadParam(m, iter, &is_null))
 349     return false;
 350   *r = NullableString16(string, is_null);
 351   return true;
 352 }
 353
 354 void ParamTraits<NullableString16>::Log(const param_type& p, std::string* l) {
 355   l->append("(");
 356   LogParam(p.string(), l);
 357   l->append(", ");
 358   LogParam(p.is_null(), l);
 359   l->append(")");
 360 }
 361
 362 #if !defined(WCHAR_T_IS_UTF16)
 363 void ParamTraits<string16>::Log(const param_type& p, std::string* l) {
 364   l->append(UTF16ToUTF8(p));
 365 }
 366 #endif
 367
 368 */
 369
 370 /*
 371 void ParamTraits<FilePath>::Write(Message* m, const param_type& p) {
 372   ParamTraits<FilePath::StringType>::Write(m, p.value());
 373 }
 374
 375 bool ParamTraits<FilePath>::Read(const Message* m, void** iter, param_type* r) {
 376   FilePath::StringType value;
 377   if (!ParamTraits<FilePath::StringType>::Read(m, iter, &value))
 378     return false;
 379   *r = FilePath(value);
 380   return true;
 381 }
 382
 383 void ParamTraits<FilePath>::Log(const param_type& p, std::string* l) {
 384   ParamTraits<FilePath::StringType>::Log(p.value(), l);
 385 }
 386
 387 #if defined(OS_POSIX)
 388 void ParamTraits<base::FileDescriptor>::Write(Message* m, const param_type& p) {
 389   const bool valid = p.fd >= 0;
 390   WriteParam(m, valid);
 391
 392   if (valid) {
 393     if (!m->WriteFileDescriptor(p))
 394       NOTREACHED();
 395   }
 396 }
 397
 398 bool ParamTraits<base::FileDescriptor>::Read(const Message* m, void** iter,
 399                                              param_type* r) {
 400   bool valid;
 401   if (!ReadParam(m, iter, &valid))
 402     return false;
 403
 404   if (!valid) {
 405     r->fd = -1;
 406     r->auto_close = false;
 407     return true;
 408   }
 409
 410   return m->ReadFileDescriptor(iter, r);
 411 }
 412
 413 void ParamTraits<base::FileDescriptor>::Log(const param_type& p,
 414                                             std::string* l) {
 415   if (p.auto_close) {
 416     l->append(StringPrintf("FD(%d auto-close)", p.fd));
 417   } else {
 418     l->append(StringPrintf("FD(%d)", p.fd));
 419   }
 420 }
 421 #endif  // defined(OS_POSIX)
 422
 423 void ParamTraits<IPC::ChannelHandle>::Write(Message* m, const param_type& p) {
 424   WriteParam(m, p.name);
 425 #if defined(OS_POSIX)
 426   WriteParam(m, p.socket);
 427 #endif
 428 }
 429
 430 bool ParamTraits<IPC::ChannelHandle>::Read(const Message* m, void** iter,
 431                                            param_type* r) {
 432   return ReadParam(m, iter, &r->name)
 433 #if defined(OS_POSIX)
 434       && ReadParam(m, iter, &r->socket)
 435 #endif
 436       ;
 437 }
 438
 439 void ParamTraits<IPC::ChannelHandle>::Log(const param_type& p,
 440                                           std::string* l) {
 441   l->append(StringPrintf("ChannelHandle(%s", p.name.c_str()));
 442 #if defined(OS_POSIX)
 443   ParamTraits<base::FileDescriptor>::Log(p.socket, l);
 444 #endif
 445   l->append(")");
 446 }
 447
 448 LogData::LogData()
 449     : routing_id(0),
 450       type(0),
 451       sent(0),
 452       receive(0),
 453       dispatch(0) {
 454 }
 455
 456 LogData::~LogData() {
 457 }
 458
 459 void ParamTraits<LogData>::Write(Message* m, const param_type& p) {
 460   WriteParam(m, p.channel);
 461   WriteParam(m, p.routing_id);
 462   WriteParam(m, static_cast<int>(p.type));
 463   WriteParam(m, p.flags);
 464   WriteParam(m, p.sent);
 465   WriteParam(m, p.receive);
 466   WriteParam(m, p.dispatch);
 467   WriteParam(m, p.params);
 468 }
 469
 470 bool ParamTraits<LogData>::Read(const Message* m, void** iter, param_type* r) {
 471   int type = -1;
 472   bool result =
 473       ReadParam(m, iter, &r->channel) &&
 474       ReadParam(m, iter, &r->routing_id) &&
 475       ReadParam(m, iter, &type) &&
 476       ReadParam(m, iter, &r->flags) &&
 477       ReadParam(m, iter, &r->sent) &&
 478       ReadParam(m, iter, &r->receive) &&
 479       ReadParam(m, iter, &r->dispatch) &&
 480       ReadParam(m, iter, &r->params);
 481   r->type = static_cast<uint16>(type);
 482   return result;
 483 }
 484 */
 485 }  // namespace IPC