Apple-2-SW/emailler
1
0
Fork 0
mirror of https://github.com/bobbimanners/emailler.git synced 2024-11-05 00:04:46 +00:00
Code Issues Projects Releases Wiki Activity
61c8763ff4
emailler/docs/ip65_httpd_s.html

636 lines
12 KiB
HTML
Raw Blame History

<html><head><meta http-equiv="Content-Type" content="text/html; charset=utf-8"/><link rel="stylesheet" type="text/css" href="ca65-doc-style.css"/></head><body><a href="ref_index.html"><h1>ip65 technical reference</h1></a><h1>File : ip65/httpd.s</h1><pre>a simple HTTP server
to use - call httpd_start with AX pointing at routine to call for each inbound page
</pre><h2 id="functions">functions</h2><table><tr><th>function</th><th>description</th></tr><tr><td id="httpd_start">httpd_start</td><td><pre>start a HTTP server
this routine will stay in an endless loop that is broken only if user press the ABORT key (runstop on a c64)
inputs:
httpd_port_number=port number to listen on
AX = pointer to routine to callback for each inbound HTTP request=
set this to $0000 to use the default handler (which will look for requested files on the local disk).
outputs:
none
</pre></td></tr></table><h2>implementation</h2><pre id="code">;a simple HTTP server
;to use - call httpd_start with AX pointing at routine to call for each inbound page
.include "../inc/common.i"
.ifndef KPR_API_VERSION_NUMBER
.define EQU =
.include "../inc/kipper_constants.i"
.endif
HTTPD_TIMEOUT_SECONDS=5 ;what's the maximum time we let 1 connection be open for?
.export httpd_start
.import http_parse_request
.import http_get_value
.import tcp_listen
.import tcp_callback
.import ip65_process
.import check_for_abort_key
.import ip65_error
.import parse_hex_digits
.import print
.import copymem
.importzp copy_src
.importzp copy_dest
.import tcp_inbound_data_ptr
.import tcp_inbound_data_length
.import tcp_send_data_len
.import tcp_send
.import tcp_close
.import io_read_catalogue
.import native_to_ascii
.import io_read_file_with_callback
.import io_filename
.import io_callback
.import timer_seconds
.import __HTTP_VARS_LOAD__
.import __HTTP_VARS_RUN__
.import __HTTP_VARS_SIZE__
temp_ptr =copy_src
.bss
found_eol: .byte 0
connection_closed: .byte 0
output_buffer_length: .res 2
sent_header: .res 1
connection_timeout_seconds: .byte 0
tcp_buffer_ptr: .res 2
buffer_size: .res 1
skip_mode: .res 1
temp_x: .res 1
.segment "HTTP_VARS"
httpd_io_buffer: .word $2000 ;by default, use a 3k buffer at $2000 for storing inbound requests.
httpd_scratch_buffer: .word $2B00 ;by default, use a 1k buffer at $2b00 as a scratchpad
httpd_port_number: .word 80
jump_to_callback:
jmp $ffff
jump_to_embedded_routine:
jmp $ffff
get_next_byte:
lda $ffff
inc get_next_byte+1
bne @skip
inc get_next_byte+2
@skip:
rts
emit_a:
stx temp_x
ldx skip_mode
bne skip_emit_a
emit_a_ptr:
sta $ffff
inc emit_a_ptr+1
bne :+
inc emit_a_ptr+2
:
inc output_buffer_length
bne :+
inc output_buffer_length+1
lda output_buffer_length+1
cmp #2
bne :+
jsr send_buffer
:
skip_emit_a:
ldx temp_x
rts
.code
;start a HTTP server
;this routine will stay in an endless loop that is broken only if user press the ABORT key (runstop on a c64)
;inputs:
;httpd_port_number=port number to listen on
;AX = pointer to routine to callback for each inbound HTTP request=
;set this to $0000 to use the default handler (which will look for requested files on the local disk).
;outputs:
; none
httpd_start:
pha ;save AX while we relocate self modifying code
txa
pha
;relocate the self-modifying code
ldax #__HTTP_VARS_LOAD__
stax copy_src
ldax #__HTTP_VARS_RUN__
stax copy_dest
ldax #__HTTP_VARS_SIZE__
jsr copymem
pla
tax
pla
stx jump_to_callback+2
bne @not_default_handler
ldax #default_httpd_handler
jmp httpd_start
@not_default_handler:
sta jump_to_callback+1
@listen:
jsr tcp_close
ldax httpd_io_buffer
stax tcp_buffer_ptr
ldax #http_callback
stax tcp_callback
ldax httpd_port_number
jsr tcp_listen
bcc @connect_ok
rts
@connect_ok:
lda #0
sta connection_closed
sta found_eol
clc
jsr timer_seconds ;time of day clock: seconds (in BCD)
sed
adc #HTTPD_TIMEOUT_SECONDS
cmp #$60
bcc @timeout_set
sec
sbc #$60
@timeout_set:
cld
sta connection_timeout_seconds
@main_polling_loop:
jsr ip65_process
jsr check_for_abort_key
bcc @no_abort
lda #KPR_ERROR_ABORTED_BY_USER
sta ip65_error
rts
@no_abort:
lda found_eol
bne @got_eol
jsr timer_seconds ;time of day clock: seconds
cmp connection_timeout_seconds
beq @connection_timed_out
lda connection_closed
beq @main_polling_loop
@connection_timed_out:
jmp @listen
@got_eol:
ldax httpd_io_buffer
jsr http_parse_request
jsr jump_to_callback ;call the handler to generate the response for this request.
;AX should now point at data to be sent
;Y should contain the content type/status code
bcs :+ ;carry is set if the callback routine already sent the response
jsr send_response
:
jmp @listen ;go listen for the next request
http_callback:
lda tcp_inbound_data_length+1
cmp #$ff
bne @not_eof
inc connection_closed
@done:
rts
@not_eof:
lda found_eol
bne @done
;copy this chunk to our input buffer
ldax tcp_buffer_ptr
stax copy_dest
ldax tcp_inbound_data_ptr
stax copy_src
ldax tcp_inbound_data_length
jsr copymem
;increment the pointer into the input buffer
clc
lda tcp_buffer_ptr
adc tcp_inbound_data_length
sta tcp_buffer_ptr
sta temp_ptr
lda tcp_buffer_ptr+1
adc tcp_inbound_data_length+1
sta tcp_buffer_ptr+1
sta temp_ptr+1
;put a null byte at the end (assumes we have set temp_ptr already)
lda #0
tay
sta (temp_ptr),y
;look for CR or LF in input
sta found_eol
ldax httpd_io_buffer
stax get_next_byte+1
@look_for_eol:
jsr get_next_byte
cmp #$0a
beq @found_eol
cmp #$0d
bne @not_eol
@found_eol:
inc found_eol
rts
@not_eol:
cmp #0
bne @look_for_eol
rts
default_httpd_handler:
lda #$02
jsr http_get_value
bcc @not_error
ldy #5
clc
rts
@not_error:
stax temp_ptr
ldy #1
lda (temp_ptr),y
bne @not_index
ldax #default_html
ldy #2
clc
rts
@not_index:
;assume that 'path' is a filename
inc temp_ptr
bne :+
inc temp_ptr
:
lda #0
sta sent_header
ldax temp_ptr
stax io_filename
ldax #send_file_callback
stax io_callback
ldax httpd_scratch_buffer
jsr io_read_file_with_callback
bcc @sent_ok
ldy #4
clc
rts
@sent_ok:
sec
rts
send_file_callback:
sty buffer_size ;only 1 (the last) sector can ever be !=$100 bytes
lda sent_header
bne @sent_header
ldy #3 ;"application/octet-stream"
jsr send_header
inc sent_header
@sent_header:
ldax httpd_scratch_buffer
stax temp_ptr
ldy #0
@loop:
tya
pha
lda (temp_ptr),y
jsr emit_a
pla
tay
iny
cpy buffer_size
bne @loop
rts
reset_output_buffer:
ldax httpd_io_buffer
sta emit_a_ptr+1
stx emit_a_ptr+2
lda #0
sta output_buffer_length
sta output_buffer_length+1
sta skip_mode
rts
emit_disk_catalogue:
ldax httpd_scratch_buffer
jsr io_read_catalogue
lda get_next_byte+1
pha
lda get_next_byte+2
pha
ldax httpd_scratch_buffer
stax get_next_byte+1
@next_filename:
jsr get_next_byte
cmp #0
beq @done
pha
ldax #file_li_preamble
jsr emit_string
pla
pha
jsr emit_a
ldax get_next_byte+1
jsr emit_string
ldax #file_li_middle
jsr emit_string
pla
bne @convert_byte
@next_byte:
jsr get_next_byte
cmp #0
beq @done_this_filename
@convert_byte:
jsr native_to_ascii
jsr emit_a
jmp @next_byte
@done_this_filename:
ldax #file_li_postamble
jsr emit_string
jmp @next_filename
@done:
pla
sta get_next_byte+2
pla
sta get_next_byte+1
rts
send_response:
stax get_next_byte+1
jsr reset_output_buffer
jsr send_header
@response_loop:
jsr get_next_byte
cmp #0
bne @not_last_byte
@send_buffer:
jmp send_buffer
@not_last_byte:
cmp #'%'
beq @escape
@back_from_escape:
jsr emit_a
jmp @response_loop
@escape:
jsr get_next_byte
cmp #0
beq @send_buffer
cmp #'%'
beq @back_from_escape
cmp #'$'
bne :+
jsr get_next_byte
jsr http_get_value
bcs @response_loop
jsr emit_string
jmp @response_loop
:
cmp #'.'
bne :+
lda #0
sta skip_mode
jmp @response_loop
:
cmp #'?'
bne :+
lda #0
sta skip_mode
jsr get_next_byte
jsr http_get_value
bcc @response_loop
inc skip_mode
jmp @response_loop
:
cmp #'!'
bne :+
lda #0
sta skip_mode
jsr get_next_byte
jsr http_get_value
bcs @response_loop
inc skip_mode
jmp @response_loop
:
cmp #';'
bne :+
jsr get_next_byte
sta jump_to_embedded_routine+1
jsr get_next_byte
sta jump_to_embedded_routine+2
jmp @call_embedded_routine
:
cmp #':'
bne :+
jsr @get_next_hex_value
sta jump_to_embedded_routine+2
jsr @get_next_hex_value
sta jump_to_embedded_routine+1
@call_embedded_routine:
lda skip_mode
bne @dont_call_embedded_routine
ldax #emit_a
jsr jump_to_embedded_routine
@dont_call_embedded_routine:
jmp @response_loop
:
;if we got here, it's an invalid escape code
jmp @response_loop
@get_next_hex_value:
jsr get_next_byte
tax
jsr get_next_byte
jmp parse_hex_digits
send_buffer:
ldax output_buffer_length
stax tcp_send_data_len
ldax httpd_io_buffer
jsr tcp_send
jmp reset_output_buffer
send_header:
;inputs: Y = header type
;$00 = no header (assume header sent already)
;$01 = 200 OK, 'text/text'
;$02 = 200 OK, 'text/html'
;$03 = 200 OK, 'application/octet-stream'
;$04 = 404 Not Found
;$05..$FF = 500 System Error
cpy #00
bne :+
rts
:
cpy #1
bne @not_text
jsr emit_ok_status_line_and_content_type
ldax #text_text
jsr emit_string
jmp @done
@not_text:
cpy #2
bne @not_html
jsr emit_ok_status_line_and_content_type
ldax #text_html
jsr emit_string
jmp @done
@not_html:
cpy #3
bne @not_binary
jsr emit_ok_status_line_and_content_type
ldax #application_octet_stream
jsr emit_string
jmp @done
@not_binary:
cpy #4
bne @not_404
ldax #http_version
jsr emit_string
ldax #status_not_found
jsr emit_string
jsr @done
ldax #status_not_found
jmp emit_string
@not_404:
ldax #http_version
jsr emit_string
ldax #status_system_error
jsr emit_string
jsr @done
ldax #status_system_error
jmp emit_string
@done:
ldax #end_of_header
jmp emit_string
emit_ok_status_line_and_content_type:
ldax #http_version
jsr emit_string
ldax #status_ok
jsr emit_string
ldax #content_type
jmp emit_string
emit_string:
stax temp_ptr
ldy #0
@next_byte:
lda (temp_ptr),y
beq @done
jsr emit_a
iny
bne @next_byte
@done:
rts
.rodata
default_html:
.byte "<h1>Index of /</h1><br><ul>%;"
.word emit_disk_catalogue
.byte "</ul><i>kipper - the 100%% 6502 m/l web server </i> "
.byte 0
CR=$0D
LF=$0A
http_version:
.byte "HTTP/1.0 ",0
status_ok:
.byte "200 OK",CR,LF,0
status_not_found:
.byte "404 Not Found",CR,LF,0
status_system_error:
.byte "500 System Error",CR,LF,0
content_type:
.byte "Content-Type: ",0
text_text:
.byte "text/text",CR,LF,0
text_html:
.byte "text/html",CR,LF,0
application_octet_stream:
.byte "application/octet-stream",CR,LF,0
end_of_header:
.byte "Connection: Close",CR,LF
.byte "Server: Kipper_httpd/0.c64",CR,LF
.byte CR,LF,0
file_li_preamble:
.byte "<li><a href=",'"',0
file_li_middle:
.byte '"',">",0
file_li_postamble:
.byte "</a></li>",0
;-- LICENSE FOR httpd.s --
; The contents of this file are subject to the Mozilla Public License
; Version 1.1 (the "License"); you may not use this file except in
; compliance with the License. You may obtain a copy of the License at
; http://www.mozilla.org/MPL/
;
; Software distributed under the License is distributed on an "AS IS"
; basis, WITHOUT WARRANTY OF ANY KIND, either express or implied. See the
; License for the specific language governing rights and limitations
; under the License.
;
; The Original Code is ip65.
;
; The Initial Developer of the Original Code is Jonno Downes,
; jonno@jamtronix.com.
; Portions created by the Initial Developer are Copyright (C) 2009
; Jonno Downes. All Rights Reserved.
; -- LICENSE END --
</pre></body></html>
Reference in New Issue View Git Blame Copy Permalink