]> git.openstreetmap.org Git - rails.git/blob - app/controllers/application_controller.rb
Update to leaflet 1.1.0
[rails.git] / app / controllers / application_controller.rb
1 class ApplicationController < ActionController::Base
2   include SessionPersistence
3
4   protect_from_forgery
5
6   before_action :fetch_body
7
8   def authorize_web
9     if session[:user]
10       @user = User.where(:id => session[:user]).where("status IN ('active', 'confirmed', 'suspended')").first
11
12       if @user.status == "suspended"
13         session.delete(:user)
14         session_expires_automatically
15
16         redirect_to :controller => "user", :action => "suspended"
17
18       # don't allow access to any auth-requiring part of the site unless
19       # the new CTs have been seen (and accept/decline chosen).
20       elsif !@user.terms_seen && flash[:skip_terms].nil?
21         flash[:notice] = t "user.terms.you need to accept or decline"
22         if params[:referer]
23           redirect_to :controller => "user", :action => "terms", :referer => params[:referer]
24         else
25           redirect_to :controller => "user", :action => "terms", :referer => request.fullpath
26         end
27       end
28     elsif session[:token]
29       if @user = User.authenticate(:token => session[:token])
30         session[:user] = @user.id
31       end
32     end
33   rescue StandardError => ex
34     logger.info("Exception authorizing user: #{ex}")
35     reset_session
36     @user = nil
37   end
38
39   def require_user
40     unless @user
41       if request.get?
42         redirect_to :controller => "user", :action => "login", :referer => request.fullpath
43       else
44         head :forbidden
45       end
46     end
47   end
48
49   def require_oauth
50     @oauth = @user.access_token(OAUTH_KEY) if @user && defined? OAUTH_KEY
51   end
52
53   ##
54   # requires the user to be logged in by the token or HTTP methods, or have an
55   # OAuth token with the right capability. this method is a bit of a pain to call
56   # directly, since it's cumbersome to call filters with arguments in rails. to
57   # make it easier to read and write the code, there are some utility methods
58   # below.
59   def require_capability(cap)
60     # when the current token is nil, it means the user logged in with a different
61     # method, otherwise an OAuth token was used, which has to be checked.
62     unless current_token.nil?
63       unless current_token.read_attribute(cap)
64         set_locale
65         report_error t("oauth.permissions.missing"), :forbidden
66         false
67       end
68     end
69   end
70
71   ##
72   # require the user to have cookies enabled in their browser
73   def require_cookies
74     if request.cookies["_osm_session"].to_s == ""
75       if params[:cookie_test].nil?
76         session[:cookie_test] = true
77         redirect_to params.to_unsafe_h.merge(:cookie_test => "true")
78         false
79       else
80         flash.now[:warning] = t "application.require_cookies.cookies_needed"
81       end
82     else
83       session.delete(:cookie_test)
84     end
85   end
86
87   # Utility methods to make the controller filter methods easier to read and write.
88   def require_allow_read_prefs
89     require_capability(:allow_read_prefs)
90   end
91
92   def require_allow_write_prefs
93     require_capability(:allow_write_prefs)
94   end
95
96   def require_allow_write_diary
97     require_capability(:allow_write_diary)
98   end
99
100   def require_allow_write_api
101     require_capability(:allow_write_api)
102
103     if REQUIRE_TERMS_AGREED && @user.terms_agreed.nil?
104       report_error "You must accept the contributor terms before you can edit.", :forbidden
105       return false
106     end
107   end
108
109   def require_allow_read_gpx
110     require_capability(:allow_read_gpx)
111   end
112
113   def require_allow_write_gpx
114     require_capability(:allow_write_gpx)
115   end
116
117   def require_allow_write_notes
118     require_capability(:allow_write_notes)
119   end
120
121   ##
122   # require that the user is a moderator, or fill out a helpful error message
123   # and return them to the index for the controller this is wrapped from.
124   def require_moderator
125     unless @user.moderator?
126       if request.get?
127         flash[:error] = t("application.require_moderator.not_a_moderator")
128         redirect_to :action => "index"
129       else
130         head :forbidden
131       end
132     end
133   end
134
135   ##
136   # sets up the @user object for use by other methods. this is mostly called
137   # from the authorize method, but can be called elsewhere if authorisation
138   # is optional.
139   def setup_user_auth
140     # try and setup using OAuth
141     unless Authenticator.new(self, [:token]).allow?
142       username, passwd = get_auth_data # parse from headers
143       # authenticate per-scheme
144       @user = if username.nil?
145                 nil # no authentication provided - perhaps first connect (client should retry after 401)
146               elsif username == "token"
147                 User.authenticate(:token => passwd) # preferred - random token for user from db, passed in basic auth
148               else
149                 User.authenticate(:username => username, :password => passwd) # basic auth
150               end
151     end
152
153     # have we identified the user?
154     if @user
155       # check if the user has been banned
156       user_block = @user.blocks.active.take
157       unless user_block.nil?
158         set_locale
159         if user_block.zero_hour?
160           report_error t("application.setup_user_auth.blocked_zero_hour"), :forbidden
161         else
162           report_error t("application.setup_user_auth.blocked"), :forbidden
163         end
164       end
165
166       # if the user hasn't seen the contributor terms then don't
167       # allow editing - they have to go to the web site and see
168       # (but can decline) the CTs to continue.
169       if REQUIRE_TERMS_SEEN && !@user.terms_seen && flash[:skip_terms].nil?
170         set_locale
171         report_error t("application.setup_user_auth.need_to_see_terms"), :forbidden
172       end
173     end
174   end
175
176   def authorize(realm = "Web Password", errormessage = "Couldn't authenticate you")
177     # make the @user object from any auth sources we have
178     setup_user_auth
179
180     # handle authenticate pass/fail
181     unless @user
182       # no auth, the user does not exist or the password was wrong
183       response.headers["WWW-Authenticate"] = "Basic realm=\"#{realm}\""
184       render :plain => errormessage, :status => :unauthorized
185       return false
186     end
187   end
188
189   ##
190   # to be used as a before_filter *after* authorize. this checks that
191   # the user is a moderator and, if not, returns a forbidden error.
192   #
193   # NOTE: this isn't a very good way of doing it - it duplicates logic
194   # from require_moderator - but what we really need to do is a fairly
195   # drastic refactoring based on :format and respond_to? but not a
196   # good idea to do that in this branch.
197   def authorize_moderator(errormessage = "Access restricted to moderators")
198     # check user is a moderator
199     unless @user.moderator?
200       render :plain => errormessage, :status => :forbidden
201       false
202     end
203   end
204
205   def check_database_readable(need_api = false)
206     if STATUS == :database_offline || (need_api && STATUS == :api_offline)
207       if request.xhr?
208         report_error "Database offline for maintenance", :service_unavailable
209       else
210         redirect_to :controller => "site", :action => "offline"
211       end
212     end
213   end
214
215   def check_database_writable(need_api = false)
216     if STATUS == :database_offline || STATUS == :database_readonly ||
217        (need_api && (STATUS == :api_offline || STATUS == :api_readonly))
218       if request.xhr?
219         report_error "Database offline for maintenance", :service_unavailable
220       else
221         redirect_to :controller => "site", :action => "offline"
222       end
223     end
224   end
225
226   def check_api_readable
227     if api_status == :offline
228       report_error "Database offline for maintenance", :service_unavailable
229       false
230     end
231   end
232
233   def check_api_writable
234     unless api_status == :online
235       report_error "Database offline for maintenance", :service_unavailable
236       false
237     end
238   end
239
240   def database_status
241     if STATUS == :database_offline
242       :offline
243     elsif STATUS == :database_readonly
244       :readonly
245     else
246       :online
247     end
248   end
249
250   def api_status
251     status = database_status
252     if status == :online
253       if STATUS == :api_offline
254         status = :offline
255       elsif STATUS == :api_readonly
256         status = :readonly
257       end
258     end
259     status
260   end
261
262   def gpx_status
263     status = database_status
264     status = :offline if status == :online && STATUS == :gpx_offline
265     status
266   end
267
268   def require_public_data
269     unless @user.data_public?
270       report_error "You must make your edits public to upload new data", :forbidden
271       false
272     end
273   end
274
275   # Report and error to the user
276   # (If anyone ever fixes Rails so it can set a http status "reason phrase",
277   #  rather than only a status code and having the web engine make up a
278   #  phrase from that, we can also put the error message into the status
279   #  message. For now, rails won't let us)
280   def report_error(message, status = :bad_request)
281     # TODO: some sort of escaping of problem characters in the message
282     response.headers["Error"] = message
283
284     if request.headers["X-Error-Format"] &&
285        request.headers["X-Error-Format"].casecmp("xml").zero?
286       result = OSM::API.new.get_xml_doc
287       result.root.name = "osmError"
288       result.root << (XML::Node.new("status") << "#{Rack::Utils.status_code(status)} #{Rack::Utils::HTTP_STATUS_CODES[status]}")
289       result.root << (XML::Node.new("message") << message)
290
291       render :xml => result.to_s
292     else
293       render :plain => message, :status => status
294     end
295   end
296
297   def preferred_languages
298     @languages ||= if params[:locale]
299                      Locale.list(params[:locale])
300                    elsif @user
301                      @user.preferred_languages
302                    else
303                      Locale.list(http_accept_language.user_preferred_languages)
304                    end
305   end
306
307   helper_method :preferred_languages
308
309   def set_locale
310     if @user && @user.languages.empty? && !http_accept_language.user_preferred_languages.empty?
311       @user.languages = http_accept_language.user_preferred_languages
312       @user.save
313     end
314
315     I18n.locale = Locale.available.preferred(preferred_languages)
316
317     response.headers["Vary"] = "Accept-Language"
318     response.headers["Content-Language"] = I18n.locale.to_s
319   end
320
321   def api_call_handle_error
322     yield
323   rescue ActiveRecord::RecordNotFound => ex
324     head :not_found
325   rescue LibXML::XML::Error, ArgumentError => ex
326     report_error ex.message, :bad_request
327   rescue ActiveRecord::RecordInvalid => ex
328     message = "#{ex.record.class} #{ex.record.id}: "
329     ex.record.errors.each { |attr, msg| message << "#{attr}: #{msg} (#{ex.record[attr].inspect})" }
330     report_error message, :bad_request
331   rescue OSM::APIError => ex
332     report_error ex.message, ex.status
333   rescue AbstractController::ActionNotFound => ex
334     raise
335   rescue StandardError => ex
336     logger.info("API threw unexpected #{ex.class} exception: #{ex.message}")
337     ex.backtrace.each { |l| logger.info(l) }
338     report_error "#{ex.class}: #{ex.message}", :internal_server_error
339   end
340
341   ##
342   # asserts that the request method is the +method+ given as a parameter
343   # or raises a suitable error. +method+ should be a symbol, e.g: :put or :get.
344   def assert_method(method)
345     ok = request.send((method.to_s.downcase + "?").to_sym)
346     raise OSM::APIBadMethodError.new(method) unless ok
347   end
348
349   ##
350   # wrap an api call in a timeout
351   def api_call_timeout
352     OSM::Timer.timeout(API_TIMEOUT, Timeout::Error) do
353       yield
354     end
355   rescue Timeout::Error
356     raise OSM::APITimeoutError
357   end
358
359   ##
360   # wrap a web page in a timeout
361   def web_timeout
362     OSM::Timer.timeout(WEB_TIMEOUT, Timeout::Error) do
363       yield
364     end
365   rescue ActionView::Template::Error => ex
366     ex = ex.original_exception
367
368     if ex.is_a?(Timeout::Error) ||
369        (ex.is_a?(ActiveRecord::StatementInvalid) && ex.message =~ /execution expired/)
370       render :action => "timeout"
371     else
372       raise
373     end
374   rescue Timeout::Error
375     render :action => "timeout"
376   end
377
378   ##
379   # ensure that there is a "this_user" instance variable
380   def lookup_this_user
381     unless @this_user = User.active.find_by(:display_name => params[:display_name])
382       render_unknown_user params[:display_name]
383     end
384   end
385
386   ##
387   # render a "no such user" page
388   def render_unknown_user(name)
389     @title = t "user.no_such_user.title"
390     @not_found_user = name
391
392     respond_to do |format|
393       format.html { render :template => "user/no_such_user", :status => :not_found }
394       format.all { head :not_found }
395     end
396   end
397
398   ##
399   # Unfortunately if a PUT or POST request that has a body fails to
400   # read it then Apache will sometimes fail to return the response it
401   # is given to the client properly, instead erroring:
402   #
403   #   https://issues.apache.org/bugzilla/show_bug.cgi?id=44782
404   #
405   # To work round this we call rewind on the body here, which is added
406   # as a filter, to force it to be fetched from Apache into a file.
407   def fetch_body
408     request.body.rewind
409   end
410
411   def map_layout
412     append_content_security_policy_directives(
413       :connect_src => %w[nominatim.openstreetmap.org overpass-api.de router.project-osrm.org valhalla.mapzen.com],
414       :script_src => %w[graphhopper.com open.mapquestapi.com],
415       :img_src => %w[developer.mapquest.com]
416     )
417
418     if STATUS == :database_offline || STATUS == :api_offline
419       flash.now[:warning] = t("layouts.osm_offline")
420     elsif STATUS == :database_readonly || STATUS == :api_readonly
421       flash.now[:warning] = t("layouts.osm_read_only")
422     end
423
424     request.xhr? ? "xhr" : "map"
425   end
426
427   def preferred_editor
428     editor = if params[:editor]
429                params[:editor]
430              elsif @user && @user.preferred_editor
431                @user.preferred_editor
432              else
433                DEFAULT_EDITOR
434              end
435
436     editor
437   end
438
439   helper_method :preferred_editor
440
441   def update_totp
442     if defined?(TOTP_KEY)
443       cookies["_osm_totp_token"] = {
444         :value => ROTP::TOTP.new(TOTP_KEY, :interval => 3600).now,
445         :domain => "openstreetmap.org",
446         :expires => 1.hour.from_now
447       }
448     end
449   end
450
451   private
452
453   # extract authorisation credentials from headers, returns user = nil if none
454   def get_auth_data
455     if request.env.key? "X-HTTP_AUTHORIZATION" # where mod_rewrite might have put it
456       authdata = request.env["X-HTTP_AUTHORIZATION"].to_s.split
457     elsif request.env.key? "REDIRECT_X_HTTP_AUTHORIZATION" # mod_fcgi
458       authdata = request.env["REDIRECT_X_HTTP_AUTHORIZATION"].to_s.split
459     elsif request.env.key? "HTTP_AUTHORIZATION" # regular location
460       authdata = request.env["HTTP_AUTHORIZATION"].to_s.split
461     end
462     # only basic authentication supported
463     if authdata && authdata[0] == "Basic"
464       user, pass = Base64.decode64(authdata[1]).split(":", 2)
465     end
466     [user, pass]
467   end
468
469   # used by oauth plugin to get the current user
470   def current_user
471     @user
472   end
473
474   # used by oauth plugin to set the current user
475   def current_user=(user)
476     @user = user
477   end
478
479   # override to stop oauth plugin sending errors
480   def invalid_oauth_response; end
481 end