cloud_print/gcp20/prototype/printer.cc

   1 // Copyright 2013 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 "cloud_print/gcp20/prototype/printer.h"
   6
   7 #include <limits.h>
   8 #include <stdio.h>
   9 #include <algorithm>
  10 #include <string>
  11 #include <vector>
  12
  13 #include "base/bind.h"
  14 #include "base/command_line.h"
  15 #include "base/files/file_util.h"
  16 #include "base/format_macros.h"
  17 #include "base/guid.h"
  18 #include "base/json/json_reader.h"
  19 #include "base/json/json_writer.h"
  20 #include "base/rand_util.h"
  21 #include "base/strings/string_number_conversions.h"
  22 #include "base/strings/string_util.h"
  23 #include "base/strings/stringprintf.h"
  24 #include "cloud_print/gcp20/prototype/command_line_reader.h"
  25 #include "cloud_print/gcp20/prototype/gcp20_switches.h"
  26 #include "cloud_print/gcp20/prototype/local_settings.h"
  27 #include "cloud_print/gcp20/prototype/service_parameters.h"
  28 #include "cloud_print/gcp20/prototype/special_io.h"
  29 #include "cloud_print/version.h"
  30 #include "net/base/net_util.h"
  31 #include "net/base/url_util.h"
  32
  33 const char kPrinterStatePathDefault[] = "printer_state.json";
  34
  35 namespace {
  36
  37 const uint16 kHttpPortDefault = 10101;
  38 const uint32 kTtlDefault = 60*60;  // in seconds
  39
  40 const char kServiceType[] = "_privet._tcp.local";
  41 const char kSecondaryServiceType[] = "_printer._sub._privet._tcp.local";
  42 const char kServiceNamePrefixDefault[] = "gcp20_device_";
  43 const char kServiceDomainNameFormatDefault[] = "my-privet-device%d.local";
  44
  45 const char kPrinterName[] = "Google GCP2.0 Prototype";
  46 const char kPrinterDescription[] = "Printer emulator";
  47
  48 const char kUserConfirmationTitle[] = "Confirm registration: type 'y' if you "
  49                                       "agree and any other to discard\n";
  50 const int kUserConfirmationTimeout = 30;  // in seconds
  51 const int kRegistrationTimeout = 60;  // in seconds
  52 const int kReconnectTimeout = 5;  // in seconds
  53
  54 const double kTimeToNextAccessTokenUpdate = 0.8;  // relatively to living time.
  55
  56 const char kCdd[] =
  57 "{"
  58 "  'version': '1.0',"
  59 "  'printer': {"
  60 "    'supported_content_type': ["
  61 "      {"
  62 "        'content_type': 'application/pdf'"
  63 "      },"
  64 "      {"
  65 "        'content_type': 'image/pwg-raster'"
  66 "      },"
  67 "      {"
  68 "        'content_type': 'image/jpeg'"
  69 "      }"
  70 "    ],"
  71 "    'color': {"
  72 "     'option': ["
  73 "        {"
  74 "          'is_default': true,"
  75 "          'type': 'STANDARD_COLOR'"
  76 "        },"
  77 "        {"
  78 "          'type': 'STANDARD_MONOCHROME'"
  79 "        }"
  80 "      ]"
  81 "    },"
  82 "    'media_size': {"
  83 "       'option': [ {"
  84 "          'height_microns': 297000,"
  85 "          'name': 'ISO_A4',"
  86 "          'width_microns': 210000"
  87 "       }, {"
  88 "          'custom_display_name': 'Letter',"
  89 "          'height_microns': 279400,"
  90 "          'is_default': true,"
  91 "          'name': 'NA_LETTER',"
  92 "          'width_microns': 215900"
  93 "       } ]"
  94 "    },"
  95 "    'page_orientation': {"
  96 "       'option': [ {"
  97 "          'is_default': true,"
  98 "          'type': 'PORTRAIT'"
  99 "       }, {"
 100 "          'type': 'LANDSCAPE'"
 101 "       } ]"
 102 "    },"
 103 "    'reverse_order': {"
 104 "      'default': false"
 105 "    }"
 106 "  }"
 107 "}";
 108
 109 // Returns local IP address number of first interface found (except loopback).
 110 // Return value is empty if no interface found. Possible interfaces names are
 111 // "eth0", "wlan0" etc. If interface name is empty, function will return IP
 112 // address of first interface found.
 113 net::IPAddressNumber GetLocalIp(const std::string& interface_name,
 114                                 bool return_ipv6_number) {
 115   net::NetworkInterfaceList interfaces;
 116   bool success = net::GetNetworkList(
 117       &interfaces, net::INCLUDE_HOST_SCOPE_VIRTUAL_INTERFACES);
 118   DCHECK(success);
 119
 120   size_t expected_address_size = return_ipv6_number ? net::kIPv6AddressSize
 121                                                     : net::kIPv4AddressSize;
 122
 123   for (net::NetworkInterfaceList::iterator iter = interfaces.begin();
 124        iter != interfaces.end(); ++iter) {
 125     if (iter->address.size() == expected_address_size &&
 126         (interface_name.empty() || interface_name == iter->name)) {
 127       return iter->address;
 128     }
 129   }
 130
 131   return net::IPAddressNumber();
 132 }
 133
 134 std::string GetDescription() {
 135   std::string result = kPrinterDescription;
 136   net::IPAddressNumber ip = GetLocalIp("", false);
 137   if (!ip.empty())
 138     result += " at " + net::IPAddressToString(ip);
 139   return result;
 140 }
 141
 142 scoped_refptr<base::SingleThreadTaskRunner> GetTaskRunner() {
 143   return base::MessageLoop::current()->message_loop_proxy();
 144 }
 145
 146 }  // namespace
 147
 148 using cloud_print_response_parser::Job;
 149
 150 Printer::Printer()
 151     : connection_state_(OFFLINE),
 152       http_server_(this),
 153       on_idle_posted_(false),
 154       pending_local_settings_check_(false),
 155       pending_print_jobs_check_(false),
 156       pending_deletion_(false) {
 157 }
 158
 159 Printer::~Printer() {
 160   Stop();
 161 }
 162
 163 bool Printer::Start() {
 164   if (IsRunning())
 165     return true;
 166
 167   LoadFromFile();
 168
 169   if (state_.local_settings.local_discovery && !StartLocalDiscoveryServers())
 170     return false;
 171
 172   print_job_handler_.reset(new PrintJobHandler);
 173   xtoken_ = XPrivetToken();
 174   starttime_ = base::Time::Now();
 175
 176   TryConnect();
 177   return true;
 178 }
 179
 180 bool Printer::IsRunning() const {
 181   return print_job_handler_;
 182 }
 183
 184 void Printer::Stop() {
 185   if (!IsRunning())
 186     return;
 187   dns_server_.Shutdown();
 188   http_server_.Shutdown();
 189   requester_.reset();
 190   print_job_handler_.reset();
 191   xmpp_listener_.reset();
 192 }
 193
 194 std::string Printer::GetRawCdd() {
 195   std::string json_str;
 196   base::JSONWriter::WriteWithOptions(&GetCapabilities(),
 197                                      base::JSONWriter::OPTIONS_PRETTY_PRINT,
 198                                      &json_str);
 199   return json_str;
 200 }
 201
 202 void Printer::OnAuthError() {
 203   LOG(ERROR) << "Auth error occurred";
 204   state_.access_token_update = base::Time();
 205   FallOffline(true);
 206 }
 207
 208 std::string Printer::GetAccessToken() {
 209   return state_.access_token;
 210 }
 211
 212 PrivetHttpServer::RegistrationErrorStatus Printer::RegistrationStart(
 213     const std::string& user) {
 214   CheckRegistrationExpiration();
 215
 216   PrinterState::ConfirmationState conf_state = state_.confirmation_state;
 217   if (state_.registration_state == PrinterState::REGISTRATION_ERROR ||
 218       conf_state == PrinterState::CONFIRMATION_TIMEOUT ||
 219       conf_state == PrinterState::CONFIRMATION_DISCARDED) {
 220     state_ = PrinterState();
 221   }
 222
 223   PrivetHttpServer::RegistrationErrorStatus status = CheckCommonRegErrors(user);
 224   if (status != PrivetHttpServer::REG_ERROR_OK)
 225     return status;
 226
 227   if (state_.registration_state != PrinterState::UNREGISTERED)
 228     return PrivetHttpServer::REG_ERROR_INVALID_ACTION;
 229
 230   UpdateRegistrationExpiration();
 231
 232   state_ = PrinterState();
 233   state_.user = user;
 234   state_.registration_state = PrinterState::REGISTRATION_STARTED;
 235
 236   if (CommandLine::ForCurrentProcess()->HasSwitch("disable-confirmation")) {
 237     state_.confirmation_state = PrinterState::CONFIRMATION_CONFIRMED;
 238     VLOG(0) << "Registration confirmed by default.";
 239   } else {
 240     LOG(WARNING) << kUserConfirmationTitle;
 241     base::Time valid_until = base::Time::Now() +
 242         base::TimeDelta::FromSeconds(kUserConfirmationTimeout);
 243     base::MessageLoop::current()->PostTask(
 244         FROM_HERE,
 245         base::Bind(&Printer::WaitUserConfirmation, AsWeakPtr(), valid_until));
 246   }
 247
 248   requester_->StartRegistration(GenerateProxyId(), kPrinterName, user,
 249                                 state_.local_settings, GetRawCdd());
 250
 251   return PrivetHttpServer::REG_ERROR_OK;
 252 }
 253
 254 PrivetHttpServer::RegistrationErrorStatus Printer::RegistrationGetClaimToken(
 255     const std::string& user,
 256     std::string* token,
 257     std::string* claim_url) {
 258   PrivetHttpServer::RegistrationErrorStatus status = CheckCommonRegErrors(user);
 259   if (status != PrivetHttpServer::REG_ERROR_OK)
 260     return status;
 261
 262   // Check if |action=start| was called, but |action=complete| wasn't.
 263   if (state_.registration_state != PrinterState::REGISTRATION_STARTED &&
 264       state_.registration_state !=
 265           PrinterState::REGISTRATION_CLAIM_TOKEN_READY) {
 266     return PrivetHttpServer::REG_ERROR_INVALID_ACTION;
 267   }
 268
 269   // If |action=getClaimToken| is valid in this state (was checked above) then
 270   // check confirmation status.
 271   if (state_.confirmation_state != PrinterState::CONFIRMATION_CONFIRMED)
 272     return ConfirmationToRegistrationError(state_.confirmation_state);
 273
 274   UpdateRegistrationExpiration();
 275
 276   // If reply wasn't received yet, reply with |pending_user_action| error.
 277   if (state_.registration_state == PrinterState::REGISTRATION_STARTED)
 278     return PrivetHttpServer::REG_ERROR_PENDING_USER_ACTION;
 279
 280   DCHECK_EQ(state_.confirmation_state, PrinterState::CONFIRMATION_CONFIRMED);
 281   DCHECK_EQ(state_.registration_state,
 282             PrinterState::REGISTRATION_CLAIM_TOKEN_READY);
 283
 284   *token = state_.registration_token;
 285   *claim_url = state_.complete_invite_url;
 286   return PrivetHttpServer::REG_ERROR_OK;
 287 }
 288
 289 PrivetHttpServer::RegistrationErrorStatus Printer::RegistrationComplete(
 290     const std::string& user,
 291     std::string* device_id) {
 292   PrivetHttpServer::RegistrationErrorStatus status = CheckCommonRegErrors(user);
 293   if (status != PrivetHttpServer::REG_ERROR_OK)
 294     return status;
 295
 296   if (state_.registration_state != PrinterState::REGISTRATION_CLAIM_TOKEN_READY)
 297     return PrivetHttpServer::REG_ERROR_INVALID_ACTION;
 298
 299   UpdateRegistrationExpiration();
 300
 301   if (state_.confirmation_state != PrinterState::CONFIRMATION_CONFIRMED)
 302     return ConfirmationToRegistrationError(state_.confirmation_state);
 303
 304   state_.registration_state = PrinterState::REGISTRATION_COMPLETING;
 305   requester_->CompleteRegistration();
 306   *device_id = state_.device_id;
 307
 308   return PrivetHttpServer::REG_ERROR_OK;
 309 }
 310
 311 PrivetHttpServer::RegistrationErrorStatus Printer::RegistrationCancel(
 312     const std::string& user) {
 313   PrivetHttpServer::RegistrationErrorStatus status = CheckCommonRegErrors(user);
 314   if (status != PrivetHttpServer::REG_ERROR_OK &&
 315       status != PrivetHttpServer::REG_ERROR_SERVER_ERROR) {
 316     return status;
 317   }
 318
 319   if (state_.registration_state == PrinterState::UNREGISTERED)
 320     return PrivetHttpServer::REG_ERROR_INVALID_ACTION;
 321
 322   InvalidateRegistrationExpiration();
 323
 324   state_ = PrinterState();
 325
 326   requester_.reset(new CloudPrintRequester(GetTaskRunner(), this));
 327
 328   return PrivetHttpServer::REG_ERROR_OK;
 329 }
 330
 331 void Printer::GetRegistrationServerError(std::string* description) {
 332   DCHECK_EQ(state_.registration_state, PrinterState::REGISTRATION_ERROR)
 333       << "Method shouldn't be called when not needed.";
 334
 335   *description = state_.error_description;
 336 }
 337
 338 void Printer::CreateInfo(PrivetHttpServer::DeviceInfo* info) {
 339   CheckRegistrationExpiration();
 340
 341   // TODO(maksymb): Replace "text" with constants.
 342   *info = PrivetHttpServer::DeviceInfo();
 343   info->version = "1.0";
 344   info->name = kPrinterName;
 345   info->description = GetDescription();
 346   info->url = kCloudPrintUrl;
 347   info->id = state_.device_id;
 348   info->device_state = "idle";
 349   info->connection_state = ConnectionStateToString(connection_state_);
 350   info->manufacturer = COMPANY_FULLNAME_STRING;
 351   info->model = "Prototype r" + std::string(LASTCHANGE_STRING);
 352   info->serial_number = "20CB5FF2-B28C-4EFA-8DCD-516CFF0455A2";
 353   info->firmware = CHROME_VERSION_STRING;
 354   info->uptime = static_cast<int>((base::Time::Now() - starttime_).InSeconds());
 355
 356   info->x_privet_token = xtoken_.GenerateXToken();
 357
 358   // TODO(maksymb): Create enum for available APIs and replace
 359   // this API text names with constants from enum. API text names should be only
 360   // known in PrivetHttpServer.
 361   if (!IsRegistered()) {
 362     info->api.push_back("/privet/register");
 363   } else {
 364     info->api.push_back("/privet/capabilities");
 365     if (IsLocalPrintingAllowed()) {
 366       info->api.push_back("/privet/printer/createjob");
 367       info->api.push_back("/privet/printer/submitdoc");
 368       info->api.push_back("/privet/printer/jobstate");
 369     }
 370   }
 371
 372   info->type.push_back("printer");
 373 }
 374
 375 bool Printer::IsRegistered() const {
 376   return state_.registration_state == PrinterState::REGISTERED;
 377 }
 378
 379 bool Printer::IsLocalPrintingAllowed() const {
 380   return state_.local_settings.local_printing_enabled;
 381 }
 382
 383 bool Printer::CheckXPrivetTokenHeader(const std::string& token) const {
 384   return xtoken_.CheckValidXToken(token);
 385 }
 386
 387 const base::DictionaryValue& Printer::GetCapabilities() {
 388   if (!state_.cdd.get()) {
 389     std::string cdd_string;
 390     base::ReplaceChars(kCdd, "'", "\"", &cdd_string);
 391     scoped_ptr<base::Value> json_val(base::JSONReader::Read(cdd_string));
 392     base::DictionaryValue* json = NULL;
 393     CHECK(json_val->GetAsDictionary(&json));
 394     state_.cdd.reset(json->DeepCopy());
 395   }
 396   return *state_.cdd;
 397 }
 398
 399 LocalPrintJob::CreateResult Printer::CreateJob(const std::string& ticket,
 400                                                std::string* job_id,
 401                                                int* expires_in,
 402                                                int* error_timeout,
 403                                                std::string* error_description) {
 404   return print_job_handler_->CreatePrintJob(ticket, job_id, expires_in,
 405                                             error_timeout, error_description);
 406 }
 407
 408 LocalPrintJob::SaveResult Printer::SubmitDoc(const LocalPrintJob& job,
 409                                              std::string* job_id,
 410                                              int* expires_in,
 411                                              std::string* error_description,
 412                                              int* timeout) {
 413   return print_job_handler_->SaveLocalPrintJob(job, job_id, expires_in,
 414                                                error_description, timeout);
 415 }
 416
 417 LocalPrintJob::SaveResult Printer::SubmitDocWithId(
 418     const LocalPrintJob& job,
 419     const std::string& job_id,
 420     int* expires_in,
 421     std::string* error_description,
 422     int* timeout) {
 423   return print_job_handler_->CompleteLocalPrintJob(job, job_id, expires_in,
 424                                                    error_description, timeout);
 425 }
 426
 427 bool Printer::GetJobState(const std::string& id, LocalPrintJob::Info* info) {
 428   return print_job_handler_->GetJobState(id, info);
 429 }
 430
 431 void Printer::OnRegistrationStartResponseParsed(
 432     const std::string& registration_token,
 433     const std::string& complete_invite_url,
 434     const std::string& device_id) {
 435   state_.registration_state = PrinterState::REGISTRATION_CLAIM_TOKEN_READY;
 436   state_.device_id = device_id;
 437   state_.registration_token = registration_token;
 438   state_.complete_invite_url = complete_invite_url;
 439 }
 440
 441 void Printer::OnRegistrationFinished(const std::string& refresh_token,
 442                                      const std::string& access_token,
 443                                      int access_token_expires_in_seconds) {
 444   InvalidateRegistrationExpiration();
 445
 446   state_.registration_state = PrinterState::REGISTERED;
 447   state_.refresh_token = refresh_token;
 448   RememberAccessToken(access_token, access_token_expires_in_seconds);
 449   TryConnect();
 450 }
 451
 452 void Printer::OnAccesstokenReceviced(const std::string& access_token,
 453                                      int expires_in_seconds) {
 454   VLOG(3) << "Function: " << __FUNCTION__;
 455   RememberAccessToken(access_token, expires_in_seconds);
 456   switch (connection_state_) {
 457     case ONLINE:
 458       PostOnIdle();
 459       break;
 460
 461     case CONNECTING:
 462       TryConnect();
 463       break;
 464
 465     default:
 466       NOTREACHED();
 467   }
 468 }
 469
 470 void Printer::OnXmppJidReceived(const std::string& xmpp_jid) {
 471   state_.xmpp_jid = xmpp_jid;
 472 }
 473
 474 void Printer::OnRegistrationError(const std::string& description) {
 475   LOG(ERROR) << "server_error: " << description;
 476
 477   SetRegistrationError(description);
 478 }
 479
 480 void Printer::OnNetworkError() {
 481   VLOG(3) << "Function: " << __FUNCTION__;
 482   FallOffline(false);
 483 }
 484
 485 void Printer::OnServerError(const std::string& description) {
 486   VLOG(3) << "Function: " << __FUNCTION__;
 487   LOG(ERROR) << "Server error: " << description;
 488   FallOffline(false);
 489 }
 490
 491 void Printer::OnPrintJobsAvailable(const std::vector<Job>& jobs) {
 492   VLOG(3) << "Function: " << __FUNCTION__;
 493
 494   VLOG(0) << "Available printjobs: " << jobs.size();
 495   if (jobs.empty()) {
 496     pending_print_jobs_check_ = false;
 497     PostOnIdle();
 498     return;
 499   }
 500
 501   VLOG(0) << "Downloading printjob.";
 502   requester_->RequestPrintJob(jobs[0]);
 503   return;
 504 }
 505
 506 void Printer::OnPrintJobDownloaded(const Job& job) {
 507   VLOG(3) << "Function: " << __FUNCTION__;
 508   print_job_handler_->SavePrintJob(job.file, job.ticket, job.create_time,
 509                                    job.job_id, job.title, "pdf");
 510   requester_->SendPrintJobDone(job.job_id);
 511 }
 512
 513 void Printer::OnPrintJobDone() {
 514   VLOG(3) << "Function: " << __FUNCTION__;
 515   PostOnIdle();
 516 }
 517
 518 void Printer::OnLocalSettingsReceived(LocalSettings::State state,
 519                                       const LocalSettings& settings) {
 520   pending_local_settings_check_ = false;
 521   switch (state) {
 522     case LocalSettings::CURRENT:
 523       VLOG(0) << "No new local settings";
 524       PostOnIdle();
 525       break;
 526     case LocalSettings::PENDING:
 527       VLOG(0) << "New local settings were received";
 528       ApplyLocalSettings(settings);
 529       break;
 530     case LocalSettings::PRINTER_DELETED:
 531       LOG(WARNING) << "Printer was deleted on server";
 532       pending_deletion_ = true;
 533       PostOnIdle();
 534       break;
 535
 536     default:
 537       NOTREACHED();
 538   }
 539 }
 540
 541 void Printer::OnLocalSettingsUpdated() {
 542   PostOnIdle();
 543 }
 544
 545 void Printer::OnXmppConnected() {
 546   pending_local_settings_check_ = true;
 547   pending_print_jobs_check_ = true;
 548   ChangeState(ONLINE);
 549   PostOnIdle();
 550 }
 551
 552 void Printer::OnXmppAuthError() {
 553   OnAuthError();
 554 }
 555
 556 void Printer::OnXmppNetworkError() {
 557   FallOffline(false);
 558 }
 559
 560 void Printer::OnXmppNewPrintJob(const std::string& device_id) {
 561   DCHECK_EQ(state_.device_id, device_id) << "Data should contain printer_id";
 562   pending_print_jobs_check_ = true;
 563 }
 564
 565 void Printer::OnXmppNewLocalSettings(const std::string& device_id) {
 566   DCHECK_EQ(state_.device_id, device_id) << "Data should contain printer_id";
 567   pending_local_settings_check_ = true;
 568 }
 569
 570 void Printer::OnXmppDeleteNotification(const std::string& device_id) {
 571   DCHECK_EQ(state_.device_id, device_id) << "Data should contain printer_id";
 572   pending_deletion_ = true;
 573 }
 574
 575 void Printer::TryConnect() {
 576   VLOG(3) << "Function: " << __FUNCTION__;
 577
 578   ChangeState(CONNECTING);
 579   if (!requester_)
 580     requester_.reset(new CloudPrintRequester(GetTaskRunner(), this));
 581
 582   if (IsRegistered()) {
 583     if (state_.access_token_update < base::Time::Now()) {
 584       requester_->UpdateAccesstoken(state_.refresh_token);
 585     } else {
 586       ConnectXmpp();
 587     }
 588   } else {
 589     // TODO(maksymb): Ping google.com to check connection state.
 590     ChangeState(ONLINE);
 591   }
 592 }
 593
 594 void Printer::ConnectXmpp() {
 595   xmpp_listener_.reset(
 596       new CloudPrintXmppListener(state_.xmpp_jid,
 597                                  state_.local_settings.xmpp_timeout_value,
 598                                  GetTaskRunner(), this));
 599   xmpp_listener_->Connect(state_.access_token);
 600 }
 601
 602 void Printer::OnIdle() {
 603   DCHECK(IsRegistered());
 604   DCHECK(on_idle_posted_) << "Instant call is not allowed";
 605   on_idle_posted_ = false;
 606
 607   if (connection_state_ != ONLINE)
 608     return;
 609
 610   if (pending_deletion_) {
 611     OnPrinterDeleted();
 612     return;
 613   }
 614
 615   if (state_.access_token_update < base::Time::Now()) {
 616     requester_->UpdateAccesstoken(state_.refresh_token);
 617     return;
 618   }
 619
 620   // TODO(maksymb): Check if privet-accesstoken was requested.
 621
 622   if (pending_local_settings_check_) {
 623     GetLocalSettings();
 624     return;
 625   }
 626
 627   if (pending_print_jobs_check_) {
 628     FetchPrintJobs();
 629     return;
 630   }
 631
 632   base::MessageLoop::current()->PostDelayedTask(
 633         FROM_HERE,
 634         base::Bind(&Printer::PostOnIdle, AsWeakPtr()),
 635         base::TimeDelta::FromMilliseconds(1000));
 636 }
 637
 638 void Printer::FetchPrintJobs() {
 639   VLOG(3) << "Function: " << __FUNCTION__;
 640   DCHECK(IsRegistered());
 641   requester_->FetchPrintJobs(state_.device_id);
 642 }
 643
 644 void Printer::GetLocalSettings() {
 645   VLOG(3) << "Function: " << __FUNCTION__;
 646   DCHECK(IsRegistered());
 647   requester_->RequestLocalSettings(state_.device_id);
 648 }
 649
 650 void Printer::ApplyLocalSettings(const LocalSettings& settings) {
 651   state_.local_settings = settings;
 652   SaveToFile();
 653
 654   if (state_.local_settings.local_discovery) {
 655     bool success = StartLocalDiscoveryServers();
 656     if (!success)
 657       LOG(ERROR) << "Local discovery servers cannot be started";
 658     // TODO(maksymb): If start failed try to start them again after some timeout
 659   } else {
 660     dns_server_.Shutdown();
 661     http_server_.Shutdown();
 662   }
 663   xmpp_listener_->set_ping_interval(state_.local_settings.xmpp_timeout_value);
 664
 665   requester_->SendLocalSettings(state_.device_id, state_.local_settings);
 666 }
 667
 668 void Printer::OnPrinterDeleted() {
 669   pending_deletion_ = false;
 670
 671   state_ = PrinterState();
 672
 673   SaveToFile();
 674   Stop();
 675   Start();
 676 }
 677
 678 void Printer::RememberAccessToken(const std::string& access_token,
 679                                   int expires_in_seconds) {
 680   using base::Time;
 681   using base::TimeDelta;
 682   state_.access_token = access_token;
 683   int64 time_to_update = static_cast<int64>(expires_in_seconds *
 684                                             kTimeToNextAccessTokenUpdate);
 685   state_.access_token_update =
 686       Time::Now() + TimeDelta::FromSeconds(time_to_update);
 687   VLOG(0) << "Current access_token: " << access_token;
 688   SaveToFile();
 689 }
 690
 691 void Printer::SetRegistrationError(const std::string& description) {
 692   DCHECK(!IsRegistered());
 693   state_.registration_state = PrinterState::REGISTRATION_ERROR;
 694   state_.error_description = description;
 695 }
 696
 697 PrivetHttpServer::RegistrationErrorStatus Printer::CheckCommonRegErrors(
 698     const std::string& user) {
 699   CheckRegistrationExpiration();
 700   DCHECK(!IsRegistered());
 701   if (connection_state_ != ONLINE)
 702     return PrivetHttpServer::REG_ERROR_OFFLINE;
 703
 704   if (state_.registration_state != PrinterState::UNREGISTERED &&
 705       user != state_.user) {
 706     return PrivetHttpServer::REG_ERROR_DEVICE_BUSY;
 707   }
 708
 709   if (state_.registration_state == PrinterState::REGISTRATION_ERROR)
 710     return PrivetHttpServer::REG_ERROR_SERVER_ERROR;
 711
 712   DCHECK_EQ(connection_state_, ONLINE);
 713
 714   return PrivetHttpServer::REG_ERROR_OK;
 715 }
 716
 717 void Printer::WaitUserConfirmation(base::Time valid_until) {
 718   // TODO(maksymb): Move to separate class.
 719
 720   if (base::Time::Now() > valid_until) {
 721     state_.confirmation_state = PrinterState::CONFIRMATION_TIMEOUT;
 722     VLOG(0) << "Confirmation timeout reached.";
 723     return;
 724   }
 725
 726   if (_kbhit()) {
 727     int c = _getche();
 728     if (c == 'y' || c == 'Y') {
 729       state_.confirmation_state = PrinterState::CONFIRMATION_CONFIRMED;
 730       VLOG(0) << "Registration confirmed by user.";
 731     } else {
 732       state_.confirmation_state = PrinterState::CONFIRMATION_DISCARDED;
 733       VLOG(0) << "Registration discarded by user.";
 734     }
 735     return;
 736   }
 737
 738   base::MessageLoop::current()->PostDelayedTask(
 739       FROM_HERE,
 740       base::Bind(&Printer::WaitUserConfirmation, AsWeakPtr(), valid_until),
 741       base::TimeDelta::FromMilliseconds(100));
 742 }
 743
 744 std::string Printer::GenerateProxyId() const {
 745   return "{" + base::GenerateGUID() +"}";
 746 }
 747
 748 std::vector<std::string> Printer::CreateTxt() const {
 749   std::vector<std::string> txt;
 750   txt.push_back("txtvers=1");
 751   txt.push_back("ty=" + std::string(kPrinterName));
 752   txt.push_back("note=" + std::string(GetDescription()));
 753   txt.push_back("url=" + std::string(kCloudPrintUrl));
 754   txt.push_back("type=printer");
 755   txt.push_back("id=" + state_.device_id);
 756   txt.push_back("cs=" + ConnectionStateToString(connection_state_));
 757
 758   return txt;
 759 }
 760
 761 void Printer::SaveToFile() {
 762   GetCapabilities();  // Make sure capabilities created.
 763   base::FilePath file_path;
 764   file_path = file_path.AppendASCII(
 765       command_line_reader::ReadStatePath(kPrinterStatePathDefault));
 766
 767   if (printer_state::SaveToFile(file_path, state_)) {
 768     VLOG(0) << "Printer state written to file";
 769   } else {
 770     VLOG(0) << "Cannot write printer state to file";
 771   }
 772 }
 773
 774 bool Printer::LoadFromFile() {
 775   state_ = PrinterState();
 776
 777   base::FilePath file_path;
 778   file_path = file_path.AppendASCII(
 779       command_line_reader::ReadStatePath(kPrinterStatePathDefault));
 780
 781   if (!base::PathExists(file_path)) {
 782     VLOG(0) << "Printer state file not found";
 783     return false;
 784   }
 785
 786   if (printer_state::LoadFromFile(file_path, &state_)) {
 787     VLOG(0) << "Printer state loaded from file";
 788     SaveToFile();
 789   } else {
 790     VLOG(0) << "Reading/parsing printer state from file failed";
 791   }
 792
 793   return true;
 794 }
 795
 796 void Printer::PostOnIdle() {
 797   VLOG(3) << "Function: " << __FUNCTION__;
 798   DCHECK(!on_idle_posted_) << "Only one instance can be posted.";
 799   on_idle_posted_ = true;
 800
 801   base::MessageLoop::current()->PostTask(
 802       FROM_HERE,
 803       base::Bind(&Printer::OnIdle, AsWeakPtr()));
 804 }
 805
 806 void Printer::CheckRegistrationExpiration() {
 807   if (!registration_expiration_.is_null() &&
 808       registration_expiration_ < base::Time::Now()) {
 809     state_ = PrinterState();
 810     InvalidateRegistrationExpiration();
 811   }
 812 }
 813
 814 void Printer::UpdateRegistrationExpiration() {
 815   registration_expiration_ =
 816       base::Time::Now() + base::TimeDelta::FromSeconds(kRegistrationTimeout);
 817 }
 818
 819 void Printer::InvalidateRegistrationExpiration() {
 820   registration_expiration_ = base::Time();
 821 }
 822
 823 bool Printer::StartLocalDiscoveryServers() {
 824   if (!StartHttpServer())
 825     return false;
 826   if (!StartDnsServer()) {
 827     http_server_.Shutdown();
 828     return false;
 829   }
 830   return true;
 831 }
 832
 833 bool Printer::StartDnsServer() {
 834   DCHECK(state_.local_settings.local_discovery);
 835
 836   net::IPAddressNumber ipv4;
 837   net::IPAddressNumber ipv6;
 838
 839   if (!base::CommandLine::ForCurrentProcess()->HasSwitch(
 840           switches::kDisableIpv4)) {
 841     ipv4 = GetLocalIp("", false);
 842   }
 843   if (!base::CommandLine::ForCurrentProcess()->HasSwitch(
 844           switches::kDisableIpv6)) {
 845     ipv6 = GetLocalIp("", true);
 846   }
 847
 848   // TODO(maksymb): Add switch for command line to control interface name.
 849   if (ipv4.empty() && ipv6.empty()) {
 850     LOG(ERROR) << "No local IP found. Cannot start printer.";
 851     return false;
 852   }
 853
 854   uint16 port = command_line_reader::ReadHttpPort(kHttpPortDefault);
 855
 856   VLOG_IF(0, !ipv4.empty())
 857       << "Local IPv4 address: " << net::IPAddressToStringWithPort(ipv4, port);
 858   VLOG_IF(0, !ipv6.empty())
 859       << "Local IPv6 address: " << net::IPAddressToStringWithPort(ipv6, port);
 860
 861   std::string service_name_prefix = kServiceNamePrefixDefault;
 862   if (!ipv4.empty())
 863     service_name_prefix += net::IPAddressToString(ipv4);
 864   service_name_prefix =
 865       command_line_reader::ReadServiceNamePrefix(service_name_prefix);
 866   std::replace(
 867       service_name_prefix.begin(), service_name_prefix.end(), '.', '_');
 868
 869   std::string service_domain_name =
 870       command_line_reader::ReadDomainName(
 871           base::StringPrintf(kServiceDomainNameFormatDefault,
 872                              base::RandInt(0, INT_MAX)));
 873
 874   ServiceParameters params(kServiceType,
 875                            kSecondaryServiceType,
 876                            service_name_prefix,
 877                            service_domain_name,
 878                            ipv4,
 879                            ipv6,
 880                            port);
 881
 882   return dns_server_.Start(params,
 883                            command_line_reader::ReadTtl(kTtlDefault),
 884                            CreateTxt());
 885 }
 886
 887 bool Printer::StartHttpServer() {
 888   DCHECK(state_.local_settings.local_discovery);
 889   using command_line_reader::ReadHttpPort;
 890   return http_server_.Start(ReadHttpPort(kHttpPortDefault));
 891 }
 892
 893 PrivetHttpServer::RegistrationErrorStatus
 894 Printer::ConfirmationToRegistrationError(
 895     PrinterState::ConfirmationState state) {
 896   switch (state) {
 897     case PrinterState::CONFIRMATION_PENDING:
 898       return PrivetHttpServer::REG_ERROR_PENDING_USER_ACTION;
 899     case PrinterState::CONFIRMATION_DISCARDED:
 900       return PrivetHttpServer::REG_ERROR_USER_CANCEL;
 901     case PrinterState::CONFIRMATION_CONFIRMED:
 902       NOTREACHED();
 903       return PrivetHttpServer::REG_ERROR_OK;
 904     case PrinterState::CONFIRMATION_TIMEOUT:
 905       return PrivetHttpServer::REG_ERROR_CONFIRMATION_TIMEOUT;
 906     default:
 907       NOTREACHED();
 908       return PrivetHttpServer::REG_ERROR_OK;
 909   }
 910 }
 911
 912 std::string Printer::ConnectionStateToString(ConnectionState state) const {
 913   switch (state) {
 914     case OFFLINE:
 915       return "offline";
 916     case ONLINE:
 917       return "online";
 918     case CONNECTING:
 919       return "connecting";
 920     case NOT_CONFIGURED:
 921       return "not-configured";
 922
 923     default:
 924       NOTREACHED();
 925       return "";
 926   }
 927 }
 928
 929 void Printer::FallOffline(bool instant_reconnect) {
 930   bool changed = ChangeState(OFFLINE);
 931   DCHECK(changed) << "Falling offline from offline is now allowed";
 932
 933   if (!IsRegistered())
 934     SetRegistrationError("Cannot access server during registration process");
 935
 936   if (instant_reconnect) {
 937     TryConnect();
 938   } else {
 939     base::MessageLoop::current()->PostDelayedTask(
 940         FROM_HERE,
 941         base::Bind(&Printer::TryConnect, AsWeakPtr()),
 942         base::TimeDelta::FromSeconds(kReconnectTimeout));
 943   }
 944 }
 945
 946 bool Printer::ChangeState(ConnectionState new_state) {
 947   if (connection_state_ == new_state)
 948     return false;
 949
 950   connection_state_ = new_state;
 951   VLOG(0) << base::StringPrintf(
 952       "Printer is now %s (%s)",
 953       ConnectionStateToString(connection_state_).c_str(),
 954       IsRegistered() ? "registered" : "unregistered");
 955
 956   dns_server_.UpdateMetadata(CreateTxt());
 957
 958   if (connection_state_ == OFFLINE) {
 959     requester_.reset();
 960     xmpp_listener_.reset();
 961   }
 962
 963   return true;
 964 }