How do I use DOS interrupt 21h/AH=25h (set interrupt vector)?

Question

I prompt the user for input:

mov ah, 0Ah
mov dx, OFFSET buffer
int 21h

My assignment tells me that ctrl-c should "abort the program with an appropriate error message".

I was told that int 23h is called whenever ctrl-c is called or detected. Apparently I can register my own interrupt handler via int 21h / ah=25h.

But I don't know how to make an interrupt handler, nor do I know where this is supposed to go in my code. Assistance would be appreciated, thank you in advance.

Melidamelilot

This question: stackoverflow.com/questions/7406055 has a working example of how to write and register an interrupt handler. – Vesicate

Answer 1

do followings to write your custom interrupt handler

SettingIntVector:
     mov ah,25h      ;Here set your ah register for calling Interrupt vector
     mov al,22h      ;Your Interrupt Address
     mov dx,IntHandlerCode   ;Interrupt Handler
     int 21h                 ;Dos Interrupt 



 IntHandlerCode:
    mov ah,9
    mov dx, offset our_text
     mov ah,9
    int 21h   
    iret

our_text db "new Interrupt Handler... $"

I hope this helped to figure out how stuff works. This Interrupt Just write "new Interrupt Handler " to screen

Obtrude

Doesn't the interrupt handler need to restore any registers it modifies? Or does the int 21h API put a wrapper around your code that does that for you? (I'm guessing it doesn't, otherwise you'd return back to some DOS code that restores regs, using ret not iret. Or is there privilege switching happening here if you're returning back to DOS rather than to your own code?) Based on Martin's answer, your function's address goes directly into the IDT, so you should need to save/restore regs. – Analyze

@PeterCordes It's essentially an API entry point, or more accurately an API callback. In this case the interrupt is required to preserve all registers, except the carry flag which is used as a return value. Since this code preserves the carry flags the interrupted MS-DOS function is restarted. Another problem with this handler is that it could be called recursively, if CTRL-C is pressed while the message is being outputted. It should be noted that DS is used as the segment of the handler, so CS == DS must be true. Finally it changes the wrong vector, 22h instead of 23h. – Averett

@RossRidge: Thanks! Interesting to see how a non-multi-tasking OS handled things like that. Is the callback really supposed to use iret, though, rather than just a near or far return? Because iret restores EFLAGS from the stack, which conflicts with your description of CF as part of the return value. Or do callbacks have the option of returning with iret or ret far 2 to pop the flags without restoring them? (Only diff I can see for real mode between iret and ret far). Also, looks like your comment would make a solid answer to the OP's question :P – Analyze

@PeterCordes In this case the handler can use either IRET, RETF 2 or RETF. The later works because MS-DOS checks SP after the call to see what it popped. – Averett

Answer 2

As far as I know function ah=25h does nothing but writing the interrupt vector to the interrupt vector table.

This table is located at address 0000:0000 and contains segment:offset pointers to the interrupts.

This means: Function 25h would simply write the segment (value of CS) to address 0000:008E and the offset (address of your interrupt handler) to 0000:008C.

Heres