app/controllers/application_controller.rb

   1 class ApplicationController < ActionController::Base
   2   include SessionPersistence
   3
   4   protect_from_forgery :with => :exception
   5
   6   rescue_from CanCan::AccessDenied, :with => :deny_access
   7   check_authorization
   8
   9   before_action :fetch_body
  10   around_action :better_errors_allow_inline, :if => proc { Rails.env.development? }
  11
  12   attr_accessor :current_user
  13
  14   helper_method :current_user
  15
  16   private
  17
  18   def authorize_web
  19     if session[:user]
  20       self.current_user = User.where(:id => session[:user]).where("status IN ('active', 'confirmed', 'suspended')").first
  21
  22       if current_user.status == "suspended"
  23         session.delete(:user)
  24         session_expires_automatically
  25
  26         redirect_to :controller => "users", :action => "suspended"
  27
  28       # don't allow access to any auth-requiring part of the site unless
  29       # the new CTs have been seen (and accept/decline chosen).
  30       elsif !current_user.terms_seen && flash[:skip_terms].nil?
  31         flash[:notice] = t "users.terms.you need to accept or decline"
  32         if params[:referer]
  33           redirect_to :controller => "users", :action => "terms", :referer => params[:referer]
  34         else
  35           redirect_to :controller => "users", :action => "terms", :referer => request.fullpath
  36         end
  37       end
  38     elsif session[:token]
  39       session[:user] = current_user.id if self.current_user = User.authenticate(:token => session[:token])
  40     end
  41   rescue StandardError => e
  42     logger.info("Exception authorizing user: #{e}")
  43     reset_session
  44     self.current_user = nil
  45   end
  46
  47   def require_user
  48     unless current_user
  49       if request.get?
  50         redirect_to :controller => "users", :action => "login", :referer => request.fullpath
  51       else
  52         head :forbidden
  53       end
  54     end
  55   end
  56
  57   def require_oauth
  58     @oauth = current_user.access_token(Settings.oauth_key) if current_user && Settings.key?(:oauth_key)
  59   end
  60
  61   ##
  62   # require the user to have cookies enabled in their browser
  63   def require_cookies
  64     if request.cookies["_osm_session"].to_s == ""
  65       if params[:cookie_test].nil?
  66         session[:cookie_test] = true
  67         redirect_to params.to_unsafe_h.merge(:cookie_test => "true")
  68         false
  69       else
  70         flash.now[:warning] = t "application.require_cookies.cookies_needed"
  71       end
  72     else
  73       session.delete(:cookie_test)
  74     end
  75   end
  76
  77   def check_database_readable(need_api = false)
  78     if Settings.status == "database_offline" || (need_api && Settings.status == "api_offline")
  79       if request.xhr?
  80         report_error "Database offline for maintenance", :service_unavailable
  81       else
  82         redirect_to :controller => "site", :action => "offline"
  83       end
  84     end
  85   end
  86
  87   def check_database_writable(need_api = false)
  88     if Settings.status == "database_offline" || Settings.status == "database_readonly" ||
  89        (need_api && (Settings.status == "api_offline" || Settings.status == "api_readonly"))
  90       if request.xhr?
  91         report_error "Database offline for maintenance", :service_unavailable
  92       else
  93         redirect_to :controller => "site", :action => "offline"
  94       end
  95     end
  96   end
  97
  98   def check_api_readable
  99     if api_status == "offline"
 100       report_error "Database offline for maintenance", :service_unavailable
 101       false
 102     end
 103   end
 104
 105   def check_api_writable
 106     unless api_status == "online"
 107       report_error "Database offline for maintenance", :service_unavailable
 108       false
 109     end
 110   end
 111
 112   def database_status
 113     if Settings.status == "database_offline"
 114       "offline"
 115     elsif Settings.status == "database_readonly"
 116       "readonly"
 117     else
 118       "online"
 119     end
 120   end
 121
 122   def api_status
 123     status = database_status
 124     if status == "online"
 125       if Settings.status == "api_offline"
 126         status = "offline"
 127       elsif Settings.status == "api_readonly"
 128         status = "readonly"
 129       end
 130     end
 131     status
 132   end
 133
 134   def require_public_data
 135     unless current_user.data_public?
 136       report_error "You must make your edits public to upload new data", :forbidden
 137       false
 138     end
 139   end
 140
 141   # Report and error to the user
 142   # (If anyone ever fixes Rails so it can set a http status "reason phrase",
 143   #  rather than only a status code and having the web engine make up a
 144   #  phrase from that, we can also put the error message into the status
 145   #  message. For now, rails won't let us)
 146   def report_error(message, status = :bad_request)
 147     # TODO: some sort of escaping of problem characters in the message
 148     response.headers["Error"] = message
 149
 150     if request.headers["X-Error-Format"]&.casecmp("xml")&.zero?
 151       result = OSM::API.new.get_xml_doc
 152       result.root.name = "osmError"
 153       result.root << (XML::Node.new("status") << "#{Rack::Utils.status_code(status)} #{Rack::Utils::HTTP_STATUS_CODES[status]}")
 154       result.root << (XML::Node.new("message") << message)
 155
 156       render :xml => result.to_s
 157     else
 158       render :plain => message, :status => status
 159     end
 160   end
 161
 162   def preferred_languages(reset = false)
 163     @preferred_languages = nil if reset
 164     @preferred_languages ||= if params[:locale]
 165                                Locale.list(params[:locale])
 166                              elsif current_user
 167                                current_user.preferred_languages
 168                              else
 169                                Locale.list(http_accept_language.user_preferred_languages)
 170                              end
 171   end
 172
 173   helper_method :preferred_languages
 174
 175   def set_locale(reset = false)
 176     if current_user&.languages&.empty? && !http_accept_language.user_preferred_languages.empty?
 177       current_user.languages = http_accept_language.user_preferred_languages
 178       current_user.save
 179     end
 180
 181     I18n.locale = Locale.available.preferred(preferred_languages(reset))
 182
 183     response.headers["Vary"] = "Accept-Language"
 184     response.headers["Content-Language"] = I18n.locale.to_s
 185   end
 186
 187   def api_call_handle_error
 188     yield
 189   rescue ActionController::UnknownFormat
 190     head :not_acceptable
 191   rescue ActiveRecord::RecordNotFound => e
 192     head :not_found
 193   rescue LibXML::XML::Error, ArgumentError => e
 194     report_error e.message, :bad_request
 195   rescue ActiveRecord::RecordInvalid => e
 196     message = "#{e.record.class} #{e.record.id}: "
 197     e.record.errors.each { |attr, msg| message << "#{attr}: #{msg} (#{e.record[attr].inspect})" }
 198     report_error message, :bad_request
 199   rescue OSM::APIError => e
 200     report_error e.message, e.status
 201   rescue AbstractController::ActionNotFound => e
 202     raise
 203   rescue StandardError => e
 204     logger.info("API threw unexpected #{e.class} exception: #{e.message}")
 205     e.backtrace.each { |l| logger.info(l) }
 206     report_error "#{e.class}: #{e.message}", :internal_server_error
 207   end
 208
 209   ##
 210   # asserts that the request method is the +method+ given as a parameter
 211   # or raises a suitable error. +method+ should be a symbol, e.g: :put or :get.
 212   def assert_method(method)
 213     ok = request.send((method.to_s.downcase + "?").to_sym)
 214     raise OSM::APIBadMethodError, method unless ok
 215   end
 216
 217   ##
 218   # wrap an api call in a timeout
 219   def api_call_timeout
 220     OSM::Timer.timeout(Settings.api_timeout, Timeout::Error) do
 221       yield
 222     end
 223   rescue Timeout::Error
 224     raise OSM::APITimeoutError
 225   end
 226
 227   ##
 228   # wrap a web page in a timeout
 229   def web_timeout
 230     OSM::Timer.timeout(Settings.web_timeout, Timeout::Error) do
 231       yield
 232     end
 233   rescue ActionView::Template::Error => e
 234     e = e.cause
 235
 236     if e.is_a?(Timeout::Error) ||
 237        (e.is_a?(ActiveRecord::StatementInvalid) && e.message =~ /execution expired/)
 238       render :action => "timeout"
 239     else
 240       raise
 241     end
 242   rescue Timeout::Error
 243     render :action => "timeout"
 244   end
 245
 246   ##
 247   # ensure that there is a "user" instance variable
 248   def lookup_user
 249     render_unknown_user params[:display_name] unless @user = User.active.find_by(:display_name => params[:display_name])
 250   end
 251
 252   ##
 253   # render a "no such user" page
 254   def render_unknown_user(name)
 255     @title = t "users.no_such_user.title"
 256     @not_found_user = name
 257
 258     respond_to do |format|
 259       format.html { render :template => "users/no_such_user", :status => :not_found }
 260       format.all { head :not_found }
 261     end
 262   end
 263
 264   ##
 265   # Unfortunately if a PUT or POST request that has a body fails to
 266   # read it then Apache will sometimes fail to return the response it
 267   # is given to the client properly, instead erroring:
 268   #
 269   #   https://issues.apache.org/bugzilla/show_bug.cgi?id=44782
 270   #
 271   # To work round this we call rewind on the body here, which is added
 272   # as a filter, to force it to be fetched from Apache into a file.
 273   def fetch_body
 274     request.body.rewind
 275   end
 276
 277   def map_layout
 278     append_content_security_policy_directives(
 279       :child_src => %w[http://127.0.0.1:8111 https://127.0.0.1:8112],
 280       :frame_src => %w[http://127.0.0.1:8111 https://127.0.0.1:8112],
 281       :connect_src => [Settings.nominatim_url, Settings.overpass_url, Settings.fossgis_osrm_url, Settings.graphhopper_url],
 282       :form_action => %w[render.openstreetmap.org],
 283       :style_src => %w['unsafe-inline']
 284     )
 285
 286     if Settings.status == "database_offline" || Settings.status == "api_offline"
 287       flash.now[:warning] = t("layouts.osm_offline")
 288     elsif Settings.status == "database_readonly" || Settings.status == "api_readonly"
 289       flash.now[:warning] = t("layouts.osm_read_only")
 290     end
 291
 292     request.xhr? ? "xhr" : "map"
 293   end
 294
 295   def allow_thirdparty_images
 296     append_content_security_policy_directives(:img_src => %w[*])
 297   end
 298
 299   def preferred_editor
 300     editor = if params[:editor]
 301                params[:editor]
 302              elsif current_user&.preferred_editor
 303                current_user.preferred_editor
 304              else
 305                Settings.default_editor
 306              end
 307
 308     editor
 309   end
 310
 311   helper_method :preferred_editor
 312
 313   def update_totp
 314     if Settings.key?(:totp_key)
 315       cookies["_osm_totp_token"] = {
 316         :value => ROTP::TOTP.new(Settings.totp_key, :interval => 3600).now,
 317         :domain => "openstreetmap.org",
 318         :expires => 1.hour.from_now
 319       }
 320     end
 321   end
 322
 323   def better_errors_allow_inline
 324     yield
 325   rescue StandardError
 326     append_content_security_policy_directives(
 327       :script_src => %w['unsafe-inline'],
 328       :style_src => %w['unsafe-inline']
 329     )
 330
 331     raise
 332   end
 333
 334   def current_ability
 335     Ability.new(current_user)
 336   end
 337
 338   def deny_access(_exception)
 339     if current_token
 340       set_locale
 341       report_error t("oauth.permissions.missing"), :forbidden
 342     elsif current_user
 343       set_locale
 344       respond_to do |format|
 345         format.html { redirect_to :controller => "errors", :action => "forbidden" }
 346         format.any { report_error t("application.permission_denied"), :forbidden }
 347       end
 348     elsif request.get?
 349       respond_to do |format|
 350         format.html { redirect_to :controller => "users", :action => "login", :referer => request.fullpath }
 351         format.any { head :forbidden }
 352       end
 353     else
 354       head :forbidden
 355     end
 356   end
 357
 358   # extract authorisation credentials from headers, returns user = nil if none
 359   def get_auth_data
 360     if request.env.key? "X-HTTP_AUTHORIZATION" # where mod_rewrite might have put it
 361       authdata = request.env["X-HTTP_AUTHORIZATION"].to_s.split
 362     elsif request.env.key? "REDIRECT_X_HTTP_AUTHORIZATION" # mod_fcgi
 363       authdata = request.env["REDIRECT_X_HTTP_AUTHORIZATION"].to_s.split
 364     elsif request.env.key? "HTTP_AUTHORIZATION" # regular location
 365       authdata = request.env["HTTP_AUTHORIZATION"].to_s.split
 366     end
 367     # only basic authentication supported
 368     user, pass = Base64.decode64(authdata[1]).split(":", 2) if authdata && authdata[0] == "Basic"
 369     [user, pass]
 370   end
 371
 372   # override to stop oauth plugin sending errors
 373   def invalid_oauth_response; end
 374 end