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