///////////////////////////////////////////////////////////////////////// // $Id: pit82c54.h,v 1.12 2003/03/02 23:59:11 cbothamy Exp $ ///////////////////////////////////////////////////////////////////////// // /* * Emulator of an Intel 8254/82C54 Programmable Interval Timer. * Greg Alexander * * This code is not yet linked into Bochs, but has been included so * that you can experiment with it. (bbd) */ #ifndef _PIT_82C54_H_ #define _PIT_82C54_H_ 1 #include "bochs.h" #ifdef BX_USE_VMX #define BX_VMX_PIT 1 #define PIT_FREQ 1193181 #endif class pit_82C54 : public logfunctions { public: //Please do not use these. They are public because they have to be // to compile on some platforms. They are not to be used by other // classes. enum rw_status { LSByte=0, MSByte=1, LSByte_multiple=2, MSByte_multiple=3 }; private: enum { MAX_COUNTER=2, MAX_ADDRESS=3, CONTROL_ADDRESS=3, MAX_MODE=5 }; enum real_RW_status { LSB_real=1, MSB_real=2, BOTH_real=3 }; enum problem_type { UNL_2P_READ=1 }; struct counter_type { //Chip IOs; bool GATE; //GATE Input value at end of cycle bool OUTpin; //OUT output this cycle //Architected state; Bit32u count; //Counter value this cycle Bit16u outlatch; //Output latch this cycle Bit16u inlatch; //Input latch this cycle Bit8u status_latch; //Status Register data; Bit8u rw_mode; //2-bit R/W mode from command word register. Bit8u mode; //3-bit mode from command word register. bool bcd_mode; //1-bit BCD vs. Binary setting. bool null_count; //Null count bit of status register. //Latch status data; bool count_LSB_latched; bool count_MSB_latched; bool status_latched; //Miscelaneous State; Bit32u count_binary; //Value of the count in binary. bool triggerGATE; //Whether we saw GATE rise this cycle. rw_status write_state; //Read state this cycle rw_status read_state; //Read state this cycle bool count_written; //Whether a count written since programmed bool first_pass; //Whether or not this is the first loaded count. bool state_bit_1; //Miscelaneous state bits. bool state_bit_2; Bit32u next_change_time; //Next time something besides count changes. //0 means never. }; counter_type counter[3]; Bit8u controlword; int seen_problems; void latch_counter(counter_type & thisctr); void set_OUT (counter_type & thisctr, bool data); void set_count (counter_type & thisctr, Bit32u data) BX_CPP_AttrRegparmN(2); void set_count_to_binary (counter_type & thisctr) BX_CPP_AttrRegparmN(1); void set_binary_to_count (counter_type & thisctr) BX_CPP_AttrRegparmN(1); void decrement (counter_type & thisctr) BX_CPP_AttrRegparmN(1); void decrement_multiple(counter_type & thisctr, Bit32u cycles) BX_CPP_AttrRegparmN(2); void clock(Bit8u cnum) BX_CPP_AttrRegparmN(1); void print_counter(counter_type & thisctr); #ifdef BX_USE_VMX void write_initcount_vmx(Bit8u cnum); #endif public: void init (void); void reset (unsigned type); pit_82C54 (void); void clock_all(Bit32u cycles); void clock_multiple(Bit8u cnum, Bit32u cycles); Bit8u read(Bit8u address); void write(Bit8u address, Bit8u data); void set_GATE(Bit8u cnum, bool data); bool read_GATE(Bit8u cnum); bool read_OUT(Bit8u cnum); Bit32u get_clock_event_time(Bit8u cnum); Bit32u get_next_event_time(void); void print_cnum(Bit8u cnum); }; #endif href='#n7'>7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 
As discussed in [the Flow View section of the mitmproxy
overview](@!urlTo("mitmproxy.html")!@), mitmproxy allows you to inspect and
manipulate flows.  When inspecting a single flow, mitmproxy uses a number of
heuristics to show a friendly view of various content types; if mitmproxy
cannot show a friendly view, mitmproxy defaults to a __raw__ view.

Each content type invokes a different flow viewer to parse the data and display
the friendly view. Users can add custom content viewers by adding a view class
to contentview.py, discussed below.

## Adding a new View class to contentview.py

The content viewers used by mitmproxy to present a friendly view of various
content types are stored in contentview.py.  Reviewing this file shows a number
of classes named ViewSomeDataType, each with the properties: __name__,
__prompt__, and __content\_types__ and a function named __\_\_call\_\___.

Adding a new content viewer to parse a data type is as simple as writing a new
View class.  Your new content viewer View class should have the same properties
as the other View classes: __name__, __prompt__, and __content\_types__ and a
__\_\_call\_\___ function to parse the content of the request/response. 

* The __name__ property should be a string describing the contents and new content viewer; 
* The __prompt__ property should be a two item tuple:

  - __1__: A string that will be used to display the new content viewer's type; and
  - __2__: A one character string that will be the hotkey used to select the new content viewer from the Flow View screen; 

* The __content\_types__ property should be a list of strings of HTTP Content\-Types that the new content viewer can parse.  
  * Note that mitmproxy will use the content\_types to try and heuristically show a friendly view of content and that you can override the built-in views by populating content\_types with values for content\_types that are already parsed -- e.g. "image/png".

After defining the __name__, __prompt__, and __content\_types__ properties of
the class, you should write the __\_\_call\_\___ function, which will parse the
request/response data and provide a friendly view of the data.  The
__\_\_call\_\___ function should take the following arguments: __self__,
__hdrs__, __content__, __limit__; __hdrs__ is a ODictCaseless object containing
the headers of the request/response; __content__ is the content of the
request/response, and __limit__ is an integer representing the amount of data
to display in the view window.

The __\_\_call\_\___ function returns two values: (1) a string describing the
parsed data; and (2) the parsed data for friendly display.  The parsed data to
be displayed should be a list of strings formatted for display.  You can use
the __\_view\_text__ function in contentview.py to format text for display.
Alternatively, you can display content as a series of key-value pairs; to do
so, prepare a list of lists, where each list item is a two item list -- a key
that describes the data, and then the data itself; after preparing the list of
lists, use the __common.format\_keyvals__ function on it to prepare it as text
for display.  

If the new content viewer fails or throws an exception, mitmproxy will default
to a __raw__ view.
generated by cgit v1.2.3 (git 2.25.1) at 2026-01-14 23:47:15 +0000